Merged revisions 80789 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 send_ping(void *data);
1107
1108 static void __send_ping(void *data)
1109 {
1110         int callno = (long)data;
1111         ast_mutex_lock(&iaxsl[callno]);
1112         if (iaxs[callno] && iaxs[callno]->pingid != -1) {
1113                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1114                 iaxs[callno]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, data);
1115         }
1116         ast_mutex_unlock(&iaxsl[callno]);
1117 }
1118
1119 static int send_ping(void *data)
1120 {
1121 #ifdef SCHED_MULTITHREADED
1122         if (schedule_action(__send_ping, data))
1123 #endif          
1124                 __send_ping(data);
1125         return 0;
1126 }
1127
1128 static int get_encrypt_methods(const char *s)
1129 {
1130         int e;
1131         if (!strcasecmp(s, "aes128"))
1132                 e = IAX_ENCRYPT_AES128;
1133         else if (ast_true(s))
1134                 e = IAX_ENCRYPT_AES128;
1135         else
1136                 e = 0;
1137         return e;
1138 }
1139
1140 static int send_lagrq(void *data);
1141
1142 static void __send_lagrq(void *data)
1143 {
1144         int callno = (long)data;
1145         /* Ping only if it's real not if it's bridged */
1146         ast_mutex_lock(&iaxsl[callno]);
1147         if (iaxs[callno] && iaxs[callno]->lagid != -1) {
1148                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1149                 iaxs[callno]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1150         }
1151         ast_mutex_unlock(&iaxsl[callno]);
1152 }
1153
1154 static int send_lagrq(void *data)
1155 {
1156 #ifdef SCHED_MULTITHREADED
1157         if (schedule_action(__send_lagrq, data))
1158 #endif          
1159                 __send_lagrq(data);
1160         return 0;
1161 }
1162
1163 static unsigned char compress_subclass(int subclass)
1164 {
1165         int x;
1166         int power=-1;
1167         /* If it's 128 or smaller, just return it */
1168         if (subclass < IAX_FLAG_SC_LOG)
1169                 return subclass;
1170         /* Otherwise find its power */
1171         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1172                 if (subclass & (1 << x)) {
1173                         if (power > -1) {
1174                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1175                                 return 0;
1176                         } else
1177                                 power = x;
1178                 }
1179         }
1180         return power | IAX_FLAG_SC_LOG;
1181 }
1182
1183 static int uncompress_subclass(unsigned char csub)
1184 {
1185         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1186         if (csub & IAX_FLAG_SC_LOG) {
1187                 /* special case for 'compressed' -1 */
1188                 if (csub == 0xff)
1189                         return -1;
1190                 else
1191                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1192         }
1193         else
1194                 return csub;
1195 }
1196
1197 /*!
1198  * \note The only member of the peer passed here guaranteed to be set is the name field
1199  */
1200 static int peer_hash_cb(const void *obj, const int flags)
1201 {
1202         const struct iax2_peer *peer = obj;
1203
1204         return ast_str_hash(peer->name);
1205 }
1206
1207 /*!
1208  * \note The only member of the peer passed here guaranteed to be set is the name field
1209  */
1210 static int peer_cmp_cb(void *obj, void *arg, int flags)
1211 {
1212         struct iax2_peer *peer = obj, *peer2 = arg;
1213
1214         return !strcasecmp(peer->name, peer2->name) ? CMP_MATCH : 0;
1215 }
1216
1217 /*!
1218  * \note The only member of the user passed here guaranteed to be set is the name field
1219  */
1220 static int user_hash_cb(const void *obj, const int flags)
1221 {
1222         const struct iax2_user *user = obj;
1223
1224         return ast_str_hash(user->name);
1225 }
1226
1227 /*!
1228  * \note The only member of the user passed here guaranteed to be set is the name field
1229  */
1230 static int user_cmp_cb(void *obj, void *arg, int flags)
1231 {
1232         struct iax2_user *user = obj, *user2 = arg;
1233
1234         return !strcasecmp(user->name, user2->name) ? CMP_MATCH : 0;
1235 }
1236
1237 /*!
1238  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
1239  *       so do not call it with a pvt lock held.
1240  */
1241 static struct iax2_peer *find_peer(const char *name, int realtime) 
1242 {
1243         struct iax2_peer *peer = NULL;
1244         struct iax2_peer tmp_peer = {
1245                 .name = name,
1246         };
1247
1248         peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
1249
1250         /* Now go for realtime if applicable */
1251         if(!peer && realtime)
1252                 peer = realtime_peer(name, NULL);
1253
1254         return peer;
1255 }
1256
1257 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
1258 {
1259         ao2_ref(peer, +1);
1260         return peer;
1261 }
1262
1263 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
1264 {
1265         ao2_ref(peer, -1);
1266         return NULL;
1267 }
1268
1269 static inline struct iax2_user *user_ref(struct iax2_user *user)
1270 {
1271         ao2_ref(user, +1);
1272         return user;
1273 }
1274
1275 static inline struct iax2_user *user_unref(struct iax2_user *user)
1276 {
1277         ao2_ref(user, -1);
1278         return NULL;
1279 }
1280
1281 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
1282 {
1283         struct iax2_peer *peer = NULL;
1284         int res = 0;
1285         ao2_iterator i;
1286
1287         i = ao2_iterator_init(peers, 0);
1288         while ((peer = ao2_iterator_next(&i))) {
1289                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1290                     (peer->addr.sin_port == sin.sin_port)) {
1291                         ast_copy_string(host, peer->name, len);
1292                         peer_unref(peer);
1293                         res = 1;
1294                         break;
1295                 }
1296                 peer_unref(peer);
1297         }
1298
1299         if (!peer) {
1300                 peer = realtime_peer(NULL, &sin);
1301                 if (peer) {
1302                         ast_copy_string(host, peer->name, len);
1303                         peer_unref(peer);
1304                         res = 1;
1305                 }
1306         }
1307
1308         return res;
1309 }
1310
1311 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1312 {
1313         struct chan_iax2_pvt *tmp;
1314         jb_conf jbconf;
1315
1316         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1317                 return NULL;
1318
1319         if (ast_string_field_init(tmp, 32)) {
1320                 ast_free(tmp);
1321                 tmp = NULL;
1322                 return NULL;
1323         }
1324                 
1325         tmp->prefs = prefs;
1326         tmp->pingid = -1;
1327         tmp->lagid = -1;
1328         tmp->autoid = -1;
1329         tmp->authid = -1;
1330         tmp->initid = -1;
1331
1332         ast_string_field_set(tmp,exten, "s");
1333         ast_string_field_set(tmp,host, host);
1334
1335         tmp->jb = jb_new();
1336         tmp->jbid = -1;
1337         jbconf.max_jitterbuf = maxjitterbuffer;
1338         jbconf.resync_threshold = resyncthreshold;
1339         jbconf.max_contig_interp = maxjitterinterps;
1340         jbconf.target_extra = jittertargetextra;
1341         jb_setconf(tmp->jb,&jbconf);
1342
1343         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1344
1345         return tmp;
1346 }
1347
1348 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1349 {
1350         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1351         if (new) {
1352                 size_t afdatalen = new->afdatalen;
1353                 memcpy(new, fr, sizeof(*new));
1354                 iax_frame_wrap(new, &fr->af);
1355                 new->afdatalen = afdatalen;
1356                 new->data = NULL;
1357                 new->datalen = 0;
1358                 new->direction = DIRECTION_INGRESS;
1359                 new->retrans = -1;
1360         }
1361         return new;
1362 }
1363
1364 #define NEW_PREVENT     0
1365 #define NEW_ALLOW       1
1366 #define NEW_FORCE       2
1367
1368 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1369 {
1370         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1371                 (cur->addr.sin_port == sin->sin_port)) {
1372                 /* This is the main host */
1373                 if ((cur->peercallno == callno) ||
1374                         ((dcallno == cur->callno) && !cur->peercallno)) {
1375                         /* That's us.  Be sure we keep track of the peer call number */
1376                         return 1;
1377                 }
1378         }
1379         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1380             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1381                 /* We're transferring */
1382                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1383                         return 1;
1384         }
1385         return 0;
1386 }
1387
1388 static void update_max_trunk(void)
1389 {
1390         int max = TRUNK_CALL_START;
1391         int x;
1392         /* XXX Prolly don't need locks here XXX */
1393         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1394                 if (iaxs[x])
1395                         max = x + 1;
1396         }
1397         maxtrunkcall = max;
1398         if (iaxdebug)
1399                 ast_debug(1, "New max trunk callno is %d\n", max);
1400 }
1401
1402 static void update_max_nontrunk(void)
1403 {
1404         int max = 1;
1405         int x;
1406         /* XXX Prolly don't need locks here XXX */
1407         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1408                 if (iaxs[x])
1409                         max = x + 1;
1410         }
1411         maxnontrunkcall = max;
1412         if (iaxdebug)
1413                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1414 }
1415
1416 static int make_trunk(unsigned short callno, int locked)
1417 {
1418         int x;
1419         int res= 0;
1420         struct timeval now = ast_tvnow();
1421         if (iaxs[callno]->oseqno) {
1422                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1423                 return -1;
1424         }
1425         if (callno & TRUNK_CALL_START) {
1426                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1427                 return -1;
1428         }
1429         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1430                 ast_mutex_lock(&iaxsl[x]);
1431                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1432                         iaxs[x] = iaxs[callno];
1433                         iaxs[x]->callno = x;
1434                         iaxs[callno] = NULL;
1435                         /* Update the two timers that should have been started */
1436                         iaxs[x]->pingid = ast_sched_replace(iaxs[x]->pingid, sched, 
1437                                 ping_time * 1000, send_ping, (void *)(long)x);
1438                         iaxs[x]->lagid = ast_sched_replace(iaxs[x]->lagid, sched, 
1439                                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
1440                         if (locked)
1441                                 ast_mutex_unlock(&iaxsl[callno]);
1442                         res = x;
1443                         if (!locked)
1444                                 ast_mutex_unlock(&iaxsl[x]);
1445                         break;
1446                 }
1447                 ast_mutex_unlock(&iaxsl[x]);
1448         }
1449         if (x >= IAX_MAX_CALLS - 1) {
1450                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1451                 return -1;
1452         }
1453         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1454         /* We move this call from a non-trunked to a trunked call */
1455         update_max_trunk();
1456         update_max_nontrunk();
1457         return res;
1458 }
1459
1460 /*!
1461  * \todo XXX Note that this function contains a very expensive operation that
1462  * happens for *every* incoming media frame.  It iterates through every
1463  * possible call number, locking and unlocking each one, to try to match the
1464  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1465  * So, for an call with a local call number of 20000, every incoming audio
1466  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1467  *
1468  * It's a shame that IAX2 media frames carry the source call number instead of
1469  * the destination call number.  If they did, this lookup wouldn't be needed.
1470  * However, it's too late to change that now.  Instead, we need to come up with
1471  * a better way of indexing active calls so that these frequent lookups are not
1472  * so expensive.
1473  *
1474  * \note Calling this function while holding another pvt lock can cause a deadlock.
1475  */
1476 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd)
1477 {
1478         int res = 0;
1479         int x;
1480         struct timeval now;
1481         char host[80];
1482
1483         if (new <= NEW_ALLOW) {
1484                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1485                         ast_mutex_lock(&iaxsl[x]);
1486                         if (iaxs[x]) {
1487                                 /* Look for an exact match */
1488                                 if (match(sin, callno, dcallno, iaxs[x])) {
1489                                         res = x;
1490                                 }
1491                         }
1492                         ast_mutex_unlock(&iaxsl[x]);
1493                 }
1494                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1495                         ast_mutex_lock(&iaxsl[x]);
1496                         if (iaxs[x]) {
1497                                 /* Look for an exact match */
1498                                 if (match(sin, callno, dcallno, iaxs[x])) {
1499                                         res = x;
1500                                 }
1501                         }
1502                         ast_mutex_unlock(&iaxsl[x]);
1503                 }
1504         }
1505         if ((res < 1) && (new >= NEW_ALLOW)) {
1506                 /* It may seem odd that we look through the peer list for a name for
1507                  * this *incoming* call.  Well, it is weird.  However, users don't
1508                  * have an IP address/port number that we can match against.  So,
1509                  * this is just checking for a peer that has that IP/port and
1510                  * assuming that we have a user of the same name.  This isn't always
1511                  * correct, but it will be changed if needed after authentication. */
1512                 if (!iax2_getpeername(*sin, host, sizeof(host)))
1513                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1514                 now = ast_tvnow();
1515                 for (x=1;x<TRUNK_CALL_START;x++) {
1516                         /* Find first unused call number that hasn't been used in a while */
1517                         ast_mutex_lock(&iaxsl[x]);
1518                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1519                         ast_mutex_unlock(&iaxsl[x]);
1520                 }
1521                 /* We've still got lock held if we found a spot */
1522                 if (x >= TRUNK_CALL_START) {
1523                         ast_log(LOG_WARNING, "No more space\n");
1524                         return 0;
1525                 }
1526                 iaxs[x] = new_iax(sin, host);
1527                 update_max_nontrunk();
1528                 if (iaxs[x]) {
1529                         if (iaxdebug)
1530                                 ast_debug(1, "Creating new call structure %d\n", x);
1531                         iaxs[x]->sockfd = sockfd;
1532                         iaxs[x]->addr.sin_port = sin->sin_port;
1533                         iaxs[x]->addr.sin_family = sin->sin_family;
1534                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1535                         iaxs[x]->peercallno = callno;
1536                         iaxs[x]->callno = x;
1537                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1538                         iaxs[x]->expiry = min_reg_expire;
1539                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1540                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1541                         iaxs[x]->amaflags = amaflags;
1542                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1543                         
1544                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1545                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1546                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1547                 } else {
1548                         ast_log(LOG_WARNING, "Out of resources\n");
1549                         ast_mutex_unlock(&iaxsl[x]);
1550                         return 0;
1551                 }
1552                 ast_mutex_unlock(&iaxsl[x]);
1553                 res = x;
1554         }
1555         return res;
1556 }
1557
1558 static void iax2_frame_free(struct iax_frame *fr)
1559 {
1560         if (fr->retrans > -1)
1561                 ast_sched_del(sched, fr->retrans);
1562         iax_frame_free(fr);
1563 }
1564
1565 /*!
1566  * \brief Queue a frame to a call's owning asterisk channel
1567  *
1568  * \pre This function assumes that iaxsl[callno] is locked when called.
1569  *
1570  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1571  * was valid before calling it, it may no longer be valid after calling it.
1572  * This function may unlock and lock the mutex associated with this callno,
1573  * meaning that another thread may grab it and destroy the call.
1574  */
1575 static int iax2_queue_frame(int callno, struct ast_frame *f)
1576 {
1577         for (;;) {
1578                 if (iaxs[callno] && iaxs[callno]->owner) {
1579                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1580                                 /* Avoid deadlock by pausing and trying again */
1581                                 ast_mutex_unlock(&iaxsl[callno]);
1582                                 usleep(1);
1583                                 ast_mutex_lock(&iaxsl[callno]);
1584                         } else {
1585                                 ast_queue_frame(iaxs[callno]->owner, f);
1586                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1587                                 break;
1588                         }
1589                 } else
1590                         break;
1591         }
1592         return 0;
1593 }
1594
1595 /*!
1596  * \brief Queue a hangup frame on the ast_channel owner
1597  *
1598  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
1599  * is active for the given call number.
1600  *
1601  * \pre Assumes lock for callno is already held.
1602  *
1603  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1604  * was valid before calling it, it may no longer be valid after calling it.
1605  * This function may unlock and lock the mutex associated with this callno,
1606  * meaning that another thread may grab it and destroy the call.
1607  */
1608 static int iax2_queue_hangup(int callno)
1609 {
1610         for (;;) {
1611                 if (iaxs[callno] && iaxs[callno]->owner) {
1612                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1613                                 /* Avoid deadlock by pausing and trying again */
1614                                 ast_mutex_unlock(&iaxsl[callno]);
1615                                 usleep(1);
1616                                 ast_mutex_lock(&iaxsl[callno]);
1617                         } else {
1618                                 ast_queue_hangup(iaxs[callno]->owner);
1619                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1620                                 break;
1621                         }
1622                 } else
1623                         break;
1624         }
1625         return 0;
1626 }
1627
1628 /*!
1629  * \brief Queue a control frame on the ast_channel owner
1630  *
1631  * This function queues a control frame on the owner of the IAX2 pvt struct that
1632  * is active for the given call number.
1633  *
1634  * \pre Assumes lock for callno is already held.
1635  *
1636  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1637  * was valid before calling it, it may no longer be valid after calling it.
1638  * This function may unlock and lock the mutex associated with this callno,
1639  * meaning that another thread may grab it and destroy the call.
1640  */
1641 static int iax2_queue_control_data(int callno, 
1642         enum ast_control_frame_type control, const void *data, size_t datalen)
1643 {
1644         for (;;) {
1645                 if (iaxs[callno] && iaxs[callno]->owner) {
1646                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1647                                 /* Avoid deadlock by pausing and trying again */
1648                                 ast_mutex_unlock(&iaxsl[callno]);
1649                                 usleep(1);
1650                                 ast_mutex_lock(&iaxsl[callno]);
1651                         } else {
1652                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
1653                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1654                                 break;
1655                         }
1656                 } else
1657                         break;
1658         }
1659         return 0;
1660 }
1661 static void destroy_firmware(struct iax_firmware *cur)
1662 {
1663         /* Close firmware */
1664         if (cur->fwh) {
1665                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1666         }
1667         close(cur->fd);
1668         ast_free(cur);
1669 }
1670
1671 static int try_firmware(char *s)
1672 {
1673         struct stat stbuf;
1674         struct iax_firmware *cur = NULL;
1675         int ifd, fd, res, len, chunk;
1676         struct ast_iax2_firmware_header *fwh, fwh2;
1677         struct MD5Context md5;
1678         unsigned char sum[16], buf[1024];
1679         char *s2, *last;
1680
1681         if (!(s2 = alloca(strlen(s) + 100))) {
1682                 ast_log(LOG_WARNING, "Alloca failed!\n");
1683                 return -1;
1684         }
1685
1686         last = strrchr(s, '/');
1687         if (last)
1688                 last++;
1689         else
1690                 last = s;
1691
1692         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1693
1694         if ((res = stat(s, &stbuf) < 0)) {
1695                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1696                 return -1;
1697         }
1698
1699         /* Make sure it's not a directory */
1700         if (S_ISDIR(stbuf.st_mode))
1701                 return -1;
1702         ifd = open(s, O_RDONLY);
1703         if (ifd < 0) {
1704                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1705                 return -1;
1706         }
1707         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1708         if (fd < 0) {
1709                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1710                 close(ifd);
1711                 return -1;
1712         }
1713         /* Unlink our newly created file */
1714         unlink(s2);
1715         
1716         /* Now copy the firmware into it */
1717         len = stbuf.st_size;
1718         while(len) {
1719                 chunk = len;
1720                 if (chunk > sizeof(buf))
1721                         chunk = sizeof(buf);
1722                 res = read(ifd, buf, chunk);
1723                 if (res != chunk) {
1724                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1725                         close(ifd);
1726                         close(fd);
1727                         return -1;
1728                 }
1729                 res = write(fd, buf, chunk);
1730                 if (res != chunk) {
1731                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1732                         close(ifd);
1733                         close(fd);
1734                         return -1;
1735                 }
1736                 len -= chunk;
1737         }
1738         close(ifd);
1739         /* Return to the beginning */
1740         lseek(fd, 0, SEEK_SET);
1741         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1742                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1743                 close(fd);
1744                 return -1;
1745         }
1746         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1747                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1748                 close(fd);
1749                 return -1;
1750         }
1751         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1752                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1753                 close(fd);
1754                 return -1;
1755         }
1756         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1757                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1758                 close(fd);
1759                 return -1;
1760         }
1761         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1762         if (fwh == (void *) -1) {
1763                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1764                 close(fd);
1765                 return -1;
1766         }
1767         MD5Init(&md5);
1768         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1769         MD5Final(sum, &md5);
1770         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1771                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1772                 munmap((void*)fwh, stbuf.st_size);
1773                 close(fd);
1774                 return -1;
1775         }
1776
1777         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1778                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1779                         /* Found a candidate */
1780                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1781                                 /* The version we have on loaded is older, load this one instead */
1782                                 break;
1783                         /* This version is no newer than what we have.  Don't worry about it.
1784                            We'll consider it a proper load anyhow though */
1785                         munmap((void*)fwh, stbuf.st_size);
1786                         close(fd);
1787                         return 0;
1788                 }
1789         }
1790         
1791         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1792                 cur->fd = -1;
1793                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1794         }
1795         
1796         if (cur) {
1797                 if (cur->fwh)
1798                         munmap((void*)cur->fwh, cur->mmaplen);
1799                 if (cur->fd > -1)
1800                         close(cur->fd);
1801                 cur->fwh = fwh;
1802                 cur->fd = fd;
1803                 cur->mmaplen = stbuf.st_size;
1804                 cur->dead = 0;
1805         }
1806         
1807         return 0;
1808 }
1809
1810 static int iax_check_version(char *dev)
1811 {
1812         int res = 0;
1813         struct iax_firmware *cur = NULL;
1814
1815         if (ast_strlen_zero(dev))
1816                 return 0;
1817
1818         AST_LIST_LOCK(&firmwares);
1819         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1820                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1821                         res = ntohs(cur->fwh->version);
1822                         break;
1823                 }
1824         }
1825         AST_LIST_UNLOCK(&firmwares);
1826
1827         return res;
1828 }
1829
1830 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1831 {
1832         int res = -1;
1833         unsigned int bs = desc & 0xff;
1834         unsigned int start = (desc >> 8) & 0xffffff;
1835         unsigned int bytes;
1836         struct iax_firmware *cur;
1837
1838         if (ast_strlen_zero((char *)dev) || !bs)
1839                 return -1;
1840
1841         start *= bs;
1842         
1843         AST_LIST_LOCK(&firmwares);
1844         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1845                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1846                         continue;
1847                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1848                 if (start < ntohl(cur->fwh->datalen)) {
1849                         bytes = ntohl(cur->fwh->datalen) - start;
1850                         if (bytes > bs)
1851                                 bytes = bs;
1852                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1853                 } else {
1854                         bytes = 0;
1855                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1856                 }
1857                 if (bytes == bs)
1858                         res = 0;
1859                 else
1860                         res = 1;
1861                 break;
1862         }
1863         AST_LIST_UNLOCK(&firmwares);
1864
1865         return res;
1866 }
1867
1868
1869 static void reload_firmware(void)
1870 {
1871         struct iax_firmware *cur = NULL;
1872         DIR *fwd;
1873         struct dirent *de;
1874         char dir[256], fn[256];
1875
1876         AST_LIST_LOCK(&firmwares);
1877
1878         /* Mark all as dead */
1879         AST_LIST_TRAVERSE(&firmwares, cur, list)
1880                 cur->dead = 1;
1881
1882         /* Now that we have marked them dead... load new ones */
1883         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1884         fwd = opendir(dir);
1885         if (fwd) {
1886                 while((de = readdir(fwd))) {
1887                         if (de->d_name[0] != '.') {
1888                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1889                                 if (!try_firmware(fn)) {
1890                                         ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
1891                                 }
1892                         }
1893                 }
1894                 closedir(fwd);
1895         } else 
1896                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1897
1898         /* Clean up leftovers */
1899         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1900                 if (!cur->dead)
1901                         continue;
1902                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1903                 destroy_firmware(cur);
1904         }
1905         AST_LIST_TRAVERSE_SAFE_END
1906
1907         AST_LIST_UNLOCK(&firmwares);
1908 }
1909
1910 /*!
1911  * \note This function assumes that iaxsl[callno] is locked when called.
1912  *
1913  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1914  * was valid before calling it, it may no longer be valid after calling it.
1915  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
1916  * associated with this callno, meaning that another thread may grab it and destroy the call.
1917  */
1918 static int __do_deliver(void *data)
1919 {
1920         /* Just deliver the packet by using queueing.  This is called by
1921           the IAX thread with the iaxsl lock held. */
1922         struct iax_frame *fr = data;
1923         fr->retrans = -1;
1924         fr->af.has_timing_info = 0;
1925         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1926                 iax2_queue_frame(fr->callno, &fr->af);
1927         /* Free our iax frame */
1928         iax2_frame_free(fr);
1929         /* And don't run again */
1930         return 0;
1931 }
1932
1933 static int handle_error(void)
1934 {
1935         /* XXX Ideally we should figure out why an error occurred and then abort those
1936            rather than continuing to try.  Unfortunately, the published interface does
1937            not seem to work XXX */
1938 #if 0
1939         struct sockaddr_in *sin;
1940         int res;
1941         struct msghdr m;
1942         struct sock_extended_err e;
1943         m.msg_name = NULL;
1944         m.msg_namelen = 0;
1945         m.msg_iov = NULL;
1946         m.msg_control = &e;
1947         m.msg_controllen = sizeof(e);
1948         m.msg_flags = 0;
1949         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1950         if (res < 0)
1951                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1952         else {
1953                 if (m.msg_controllen) {
1954                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1955                         if (sin) 
1956                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1957                         else
1958                                 ast_log(LOG_WARNING, "No address detected??\n");
1959                 } else {
1960                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1961                 }
1962         }
1963 #endif
1964         return 0;
1965 }
1966
1967 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1968 {
1969         int res;
1970         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1971                                         sizeof(*sin));
1972         if (res < 0) {
1973                 ast_debug(1, "Received error: %s\n", strerror(errno));
1974                 handle_error();
1975         } else
1976                 res = 0;
1977         return res;
1978 }
1979
1980 static int send_packet(struct iax_frame *f)
1981 {
1982         int res;
1983         int callno = f->callno;
1984
1985         /* Don't send if there was an error, but return error instead */
1986         if (!callno || !iaxs[callno] || iaxs[callno]->error)
1987             return -1;
1988         
1989         /* Called with iaxsl held */
1990         if (iaxdebug)
1991                 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));
1992         if (f->transfer) {
1993                 if (iaxdebug)
1994                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1995                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1996                                         sizeof(iaxs[callno]->transfer));
1997         } else {
1998                 if (iaxdebug)
1999                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
2000                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
2001                                         sizeof(iaxs[callno]->addr));
2002         }
2003         if (res < 0) {
2004                 if (iaxdebug)
2005                         ast_debug(1, "Received error: %s\n", strerror(errno));
2006                 handle_error();
2007         } else
2008                 res = 0;
2009         return res;
2010 }
2011
2012 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
2013 {
2014         /* Decrement AUTHREQ count if needed */
2015         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
2016                 struct iax2_user *user;
2017                 struct iax2_user tmp_user = {
2018                         .name = pvt->username,
2019                 };
2020
2021                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
2022                 if (user) {
2023                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
2024                         user_unref(user);       
2025                 }
2026
2027                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
2028         }
2029         /* No more pings or lagrq's */
2030         if (pvt->pingid > -1)
2031                 ast_sched_del(sched, pvt->pingid);
2032         pvt->pingid = -1;
2033         if (pvt->lagid > -1)
2034                 ast_sched_del(sched, pvt->lagid);
2035         pvt->lagid = -1;
2036         if (pvt->autoid > -1)
2037                 ast_sched_del(sched, pvt->autoid);
2038         pvt->autoid = -1;
2039         if (pvt->authid > -1)
2040                 ast_sched_del(sched, pvt->authid);
2041         pvt->authid = -1;
2042         if (pvt->initid > -1)
2043                 ast_sched_del(sched, pvt->initid);
2044         pvt->initid = -1;
2045         if (pvt->jbid > -1)
2046                 ast_sched_del(sched, pvt->jbid);
2047         pvt->jbid = -1;
2048 }
2049
2050 /*!
2051  * \note Since this function calls iax2_queue_hangup(), the pvt struct
2052  *       for the given call number may disappear during its execution.
2053  */
2054 static int iax2_predestroy(int callno)
2055 {
2056         struct ast_channel *c = NULL;
2057         struct chan_iax2_pvt *pvt = iaxs[callno];
2058
2059         if (!pvt)
2060                 return -1;
2061
2062         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
2063                 iax2_destroy_helper(pvt);
2064                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2065         }
2066
2067         if ((c = pvt->owner)) {
2068                 c->tech_pvt = NULL;
2069                 iax2_queue_hangup(callno);
2070                 pvt->owner = NULL;
2071                 ast_module_unref(ast_module_info->self);
2072         }
2073
2074         return 0;
2075 }
2076
2077 static void iax2_destroy(int callno)
2078 {
2079         struct chan_iax2_pvt *pvt = NULL;
2080         struct iax_frame *cur = NULL;
2081         struct ast_channel *owner = NULL;
2082
2083 retry:
2084         pvt = iaxs[callno];
2085         lastused[callno] = ast_tvnow();
2086         
2087         owner = pvt ? pvt->owner : NULL;
2088
2089         if (owner) {
2090                 if (ast_mutex_trylock(&owner->lock)) {
2091                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
2092                         ast_mutex_unlock(&iaxsl[callno]);
2093                         usleep(1);
2094                         ast_mutex_lock(&iaxsl[callno]);
2095                         goto retry;
2096                 }
2097         }
2098         if (!owner)
2099                 iaxs[callno] = NULL;
2100         if (pvt) {
2101                 if (!owner)
2102                         pvt->owner = NULL;
2103                 iax2_destroy_helper(pvt);
2104
2105                 /* Already gone */
2106                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2107
2108                 if (owner) {
2109                         /* If there's an owner, prod it to give up */
2110                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
2111                          * because we already hold the owner channel lock. */
2112                         ast_queue_hangup(owner);
2113                 }
2114
2115                 AST_LIST_LOCK(&frame_queue);
2116                 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2117                         /* Cancel any pending transmissions */
2118                         if (cur->callno == pvt->callno) 
2119                                 cur->retries = -1;
2120                 }
2121                 AST_LIST_UNLOCK(&frame_queue);
2122
2123                 if (pvt->reg)
2124                         pvt->reg->callno = 0;
2125                 if (!owner) {
2126                         jb_frame frame;
2127                         if (pvt->vars) {
2128                             ast_variables_destroy(pvt->vars);
2129                             pvt->vars = NULL;
2130                         }
2131
2132                         while (jb_getall(pvt->jb, &frame) == JB_OK)
2133                                 iax2_frame_free(frame.data);
2134                         jb_destroy(pvt->jb);
2135                         /* gotta free up the stringfields */
2136                         ast_string_field_free_pools(pvt);
2137                         ast_free(pvt);
2138                 }
2139         }
2140         if (owner) {
2141                 ast_mutex_unlock(&owner->lock);
2142         }
2143         if (callno & 0x4000)
2144                 update_max_trunk();
2145 }
2146
2147 static int update_packet(struct iax_frame *f)
2148 {
2149         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2150         struct ast_iax2_full_hdr *fh = f->data;
2151         /* Mark this as a retransmission */
2152         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2153         /* Update iseqno */
2154         f->iseqno = iaxs[f->callno]->iseqno;
2155         fh->iseqno = f->iseqno;
2156         return 0;
2157 }
2158
2159 static int attempt_transmit(void *data);
2160 static void __attempt_transmit(void *data)
2161 {
2162         /* Attempt to transmit the frame to the remote peer...
2163            Called without iaxsl held. */
2164         struct iax_frame *f = data;
2165         int freeme = 0;
2166         int callno = f->callno;
2167         /* Make sure this call is still active */
2168         if (callno) 
2169                 ast_mutex_lock(&iaxsl[callno]);
2170         if (callno && iaxs[callno]) {
2171                 if ((f->retries < 0) /* Already ACK'd */ ||
2172                     (f->retries >= max_retries) /* Too many attempts */) {
2173                                 /* Record an error if we've transmitted too many times */
2174                                 if (f->retries >= max_retries) {
2175                                         if (f->transfer) {
2176                                                 /* Transfer timeout */
2177                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
2178                                         } else if (f->final) {
2179                                                 if (f->final) 
2180                                                         iax2_destroy(callno);
2181                                         } else {
2182                                                 if (iaxs[callno]->owner)
2183                                                         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);
2184                                                 iaxs[callno]->error = ETIMEDOUT;
2185                                                 if (iaxs[callno]->owner) {
2186                                                         struct ast_frame fr = { 0, };
2187                                                         /* Hangup the fd */
2188                                                         fr.frametype = AST_FRAME_CONTROL;
2189                                                         fr.subclass = AST_CONTROL_HANGUP;
2190                                                         iax2_queue_frame(callno, &fr); // XXX
2191                                                         /* Remember, owner could disappear */
2192                                                         if (iaxs[callno] && iaxs[callno]->owner)
2193                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2194                                                 } else {
2195                                                         if (iaxs[callno]->reg) {
2196                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2197                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2198                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2199                                                         }
2200                                                         iax2_destroy(callno);
2201                                                 }
2202                                         }
2203
2204                                 }
2205                                 freeme = 1;
2206                 } else {
2207                         /* Update it if it needs it */
2208                         update_packet(f);
2209                         /* Attempt transmission */
2210                         send_packet(f);
2211                         f->retries++;
2212                         /* Try again later after 10 times as long */
2213                         f->retrytime *= 10;
2214                         if (f->retrytime > MAX_RETRY_TIME)
2215                                 f->retrytime = MAX_RETRY_TIME;
2216                         /* Transfer messages max out at one second */
2217                         if (f->transfer && (f->retrytime > 1000))
2218                                 f->retrytime = 1000;
2219                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
2220                 }
2221         } else {
2222                 /* Make sure it gets freed */
2223                 f->retries = -1;
2224                 freeme = 1;
2225         }
2226         if (callno)
2227                 ast_mutex_unlock(&iaxsl[callno]);
2228         /* Do not try again */
2229         if (freeme) {
2230                 /* Don't attempt delivery, just remove it from the queue */
2231                 AST_LIST_LOCK(&frame_queue);
2232                 AST_LIST_REMOVE(&frame_queue, f, list);
2233                 AST_LIST_UNLOCK(&frame_queue);
2234                 f->retrans = -1;
2235                 /* Free the IAX frame */
2236                 iax2_frame_free(f);
2237         }
2238 }
2239
2240 static int attempt_transmit(void *data)
2241 {
2242 #ifdef SCHED_MULTITHREADED
2243         if (schedule_action(__attempt_transmit, data))
2244 #endif          
2245                 __attempt_transmit(data);
2246         return 0;
2247 }
2248
2249 static int iax2_prune_realtime(int fd, int argc, char *argv[])
2250 {
2251         struct iax2_peer *peer;
2252
2253         if (argc != 4)
2254         return RESULT_SHOWUSAGE;
2255         if (!strcmp(argv[3],"all")) {
2256                 reload_config();
2257                 ast_cli(fd, "OK cache is flushed.\n");
2258         } else if ((peer = find_peer(argv[3], 0))) {
2259                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2260                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2261                         expire_registry((void *)peer->name);
2262                         ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
2263                 } else {
2264                         ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
2265                 }
2266                 peer_unref(peer);
2267         } else {
2268                 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
2269         }
2270         
2271         return RESULT_SUCCESS;
2272 }
2273
2274 static int iax2_test_losspct(int fd, int argc, char *argv[])
2275 {
2276        if (argc != 4)
2277                return RESULT_SHOWUSAGE;
2278
2279        test_losspct = atoi(argv[3]);
2280
2281        return RESULT_SUCCESS;
2282 }
2283
2284 #ifdef IAXTESTS
2285 static int iax2_test_late(int fd, int argc, char *argv[])
2286 {
2287         if (argc != 4)
2288                 return RESULT_SHOWUSAGE;
2289
2290         test_late = atoi(argv[3]);
2291
2292         return RESULT_SUCCESS;
2293 }
2294
2295 static int iax2_test_resync(int fd, int argc, char *argv[])
2296 {
2297         if (argc != 4)
2298                 return RESULT_SHOWUSAGE;
2299
2300         test_resync = atoi(argv[3]);
2301
2302         return RESULT_SUCCESS;
2303 }
2304
2305 static int iax2_test_jitter(int fd, int argc, char *argv[])
2306 {
2307         if (argc < 4 || argc > 5)
2308                 return RESULT_SHOWUSAGE;
2309
2310         test_jit = atoi(argv[3]);
2311         if (argc == 5) 
2312                 test_jitpct = atoi(argv[4]);
2313
2314         return RESULT_SUCCESS;
2315 }
2316 #endif /* IAXTESTS */
2317
2318 /*! \brief  peer_status: Report Peer status in character string */
2319 /*      returns 1 if peer is online, -1 if unmonitored */
2320 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2321 {
2322         int res = 0;
2323         if (peer->maxms) {
2324                 if (peer->lastms < 0) {
2325                         ast_copy_string(status, "UNREACHABLE", statuslen);
2326                 } else if (peer->lastms > peer->maxms) {
2327                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2328                         res = 1;
2329                 } else if (peer->lastms) {
2330                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2331                         res = 1;
2332                 } else {
2333                         ast_copy_string(status, "UNKNOWN", statuslen);
2334                 }
2335         } else { 
2336                 ast_copy_string(status, "Unmonitored", statuslen);
2337                 res = -1;
2338         }
2339         return res;
2340 }
2341
2342 /*! \brief Show one peer in detail */
2343 static int iax2_show_peer(int fd, int argc, char *argv[])
2344 {
2345         char status[30];
2346         char cbuf[256];
2347         struct iax2_peer *peer;
2348         char codec_buf[512];
2349         int x = 0, codec = 0, load_realtime = 0;
2350
2351         if (argc < 4)
2352                 return RESULT_SHOWUSAGE;
2353
2354         load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2355
2356         peer = find_peer(argv[3], load_realtime);
2357         if (peer) {
2358                 ast_cli(fd,"\n\n");
2359                 ast_cli(fd, "  * Name       : %s\n", peer->name);
2360                 ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2361                 ast_cli(fd, "  Context      : %s\n", peer->context);
2362                 ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
2363                 ast_cli(fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2364                 ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2365                 ast_cli(fd, "  Expire       : %d\n", peer->expire);
2366                 ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
2367                 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));
2368                 ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2369                 ast_cli(fd, "  Username     : %s\n", peer->username);
2370                 ast_cli(fd, "  Codecs       : ");
2371                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2372                 ast_cli(fd, "%s\n", codec_buf);
2373
2374                 ast_cli(fd, "  Codec Order  : (");
2375                 for(x = 0; x < 32 ; x++) {
2376                         codec = ast_codec_pref_index(&peer->prefs,x);
2377                         if(!codec)
2378                                 break;
2379                         ast_cli(fd, "%s", ast_getformatname(codec));
2380                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2381                                 ast_cli(fd, "|");
2382                 }
2383
2384                 if (!x)
2385                         ast_cli(fd, "none");
2386                 ast_cli(fd, ")\n");
2387
2388                 ast_cli(fd, "  Status       : ");
2389                 peer_status(peer, status, sizeof(status));      
2390                 ast_cli(fd, "%s\n",status);
2391                 ast_cli(fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2392                 ast_cli(fd,"\n");
2393                 peer_unref(peer);
2394         } else {
2395                 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2396                 ast_cli(fd,"\n");
2397         }
2398
2399         return RESULT_SUCCESS;
2400 }
2401
2402 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2403 {
2404         int which = 0;
2405         struct iax2_peer *peer;
2406         char *res = NULL;
2407         int wordlen = strlen(word);
2408         ao2_iterator i;
2409
2410         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2411         if (pos != 3)
2412                 return NULL;
2413
2414         i = ao2_iterator_init(peers, 0);
2415         while ((peer = ao2_iterator_next(&i))) {
2416                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state) {
2417                         res = ast_strdup(peer->name);
2418                         peer_unref(peer);
2419                         break;
2420                 }
2421                 peer_unref(peer);
2422         }
2423
2424         return res;
2425 }
2426
2427 static int iax2_show_stats(int fd, int argc, char *argv[])
2428 {
2429         struct iax_frame *cur;
2430         int cnt = 0, dead=0, final=0;
2431
2432         if (argc != 3)
2433                 return RESULT_SHOWUSAGE;
2434
2435         AST_LIST_LOCK(&frame_queue);
2436         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2437                 if (cur->retries < 0)
2438                         dead++;
2439                 if (cur->final)
2440                         final++;
2441                 cnt++;
2442         }
2443         AST_LIST_UNLOCK(&frame_queue);
2444
2445         ast_cli(fd, "    IAX Statistics\n");
2446         ast_cli(fd, "---------------------\n");
2447         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2448         ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2449                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2450
2451         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2452
2453         trunk_timed = trunk_untimed = 0;
2454         if (trunk_maxmtu > trunk_nmaxmtu)
2455                 trunk_nmaxmtu = trunk_maxmtu;
2456         
2457         return RESULT_SUCCESS;
2458 }
2459
2460 /*! \brief Set trunk MTU from CLI */
2461 static int iax2_set_mtu(int fd, int argc, char *argv[])
2462 {
2463         int mtuv;
2464
2465         if (argc != 4)
2466                 return RESULT_SHOWUSAGE; 
2467         if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0) 
2468                 mtuv = MAX_TRUNK_MTU; 
2469         else                                         
2470                 mtuv = atoi(argv[3]); 
2471
2472         if (mtuv == 0) {
2473                 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2474                 global_max_trunk_mtu = 0; 
2475                 return RESULT_SUCCESS; 
2476         }
2477         if (mtuv < 172 || mtuv > 4000) {
2478                 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n"); 
2479                 return RESULT_SHOWUSAGE; 
2480         }
2481         ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2482         global_max_trunk_mtu = mtuv; 
2483         return RESULT_SUCCESS;
2484 }
2485
2486 static int iax2_show_cache(int fd, int argc, char *argv[])
2487 {
2488         struct iax2_dpcache *dp = NULL;
2489         char tmp[1024], *pc = NULL;
2490         int s, x, y;
2491         struct timeval tv = ast_tvnow();
2492
2493         AST_LIST_LOCK(&dpcache);
2494
2495         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2496
2497         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2498                 s = dp->expiry.tv_sec - tv.tv_sec;
2499                 tmp[0] = '\0';
2500                 if (dp->flags & CACHE_FLAG_EXISTS)
2501                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2502                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2503                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2504                 if (dp->flags & CACHE_FLAG_CANEXIST)
2505                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2506                 if (dp->flags & CACHE_FLAG_PENDING)
2507                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2508                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2509                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2510                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2511                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2512                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2513                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2514                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2515                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2516                 /* Trim trailing pipe */
2517                 if (!ast_strlen_zero(tmp))
2518                         tmp[strlen(tmp) - 1] = '\0';
2519                 else
2520                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2521                 y=0;
2522                 pc = strchr(dp->peercontext, '@');
2523                 if (!pc)
2524                         pc = dp->peercontext;
2525                 else
2526                         pc++;
2527                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2528                         if (dp->waiters[x] > -1)
2529                                 y++;
2530                 if (s > 0)
2531                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2532                 else
2533                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2534         }
2535
2536         AST_LIST_LOCK(&dpcache);
2537
2538         return RESULT_SUCCESS;
2539 }
2540
2541 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2542
2543 static void unwrap_timestamp(struct iax_frame *fr)
2544 {
2545         int x;
2546
2547         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2548                 x = fr->ts - iaxs[fr->callno]->last;
2549                 if (x < -50000) {
2550                         /* Sudden big jump backwards in timestamp:
2551                            What likely happened here is that miniframe timestamp has circled but we haven't
2552                            gotten the update from the main packet.  We'll just pretend that we did, and
2553                            update the timestamp appropriately. */
2554                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2555                         if (iaxdebug)
2556                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2557                 }
2558                 if (x > 50000) {
2559                         /* Sudden apparent big jump forwards in timestamp:
2560                            What's likely happened is this is an old miniframe belonging to the previous
2561                            top-16-bit timestamp that has turned up out of order.
2562                            Adjust the timestamp appropriately. */
2563                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2564                         if (iaxdebug)
2565                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2566                 }
2567         }
2568 }
2569
2570 static int get_from_jb(void *p);
2571
2572 static void update_jbsched(struct chan_iax2_pvt *pvt)
2573 {
2574         int when;
2575         
2576         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2577         
2578         when = jb_next(pvt->jb) - when;
2579         
2580         if(when <= 0) {
2581                 /* XXX should really just empty until when > 0.. */
2582                 when = 1;
2583         }
2584         
2585         pvt->jbid = ast_sched_replace(pvt->jbid, sched, when, get_from_jb, 
2586                 CALLNO_TO_PTR(pvt->callno));
2587         
2588         /* Signal scheduler thread */
2589         signal_condition(&sched_lock, &sched_cond);
2590 }
2591
2592 static void __get_from_jb(void *p) 
2593 {
2594         int callno = PTR_TO_CALLNO(p);
2595         struct chan_iax2_pvt *pvt = NULL;
2596         struct iax_frame *fr;
2597         jb_frame frame;
2598         int ret;
2599         long now;
2600         long next;
2601         struct timeval tv = ast_tvnow();
2602         
2603         /* Make sure we have a valid private structure before going on */
2604         ast_mutex_lock(&iaxsl[callno]);
2605         pvt = iaxs[callno];
2606         if (!pvt) {
2607                 /* No go! */
2608                 ast_mutex_unlock(&iaxsl[callno]);
2609                 return;
2610         }
2611
2612         pvt->jbid = -1;
2613         
2614         /* round up a millisecond since ast_sched_runq does; */
2615         /* prevents us from spinning while waiting for our now */
2616         /* to catch up with runq's now */
2617         tv.tv_usec += 1000;
2618         
2619         now = ast_tvdiff_ms(tv, pvt->rxcore);
2620         
2621         if(now >= (next = jb_next(pvt->jb))) {
2622                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2623                 switch(ret) {
2624                 case JB_OK:
2625                         fr = frame.data;
2626                         __do_deliver(fr);
2627                         /* __do_deliver() can cause the call to disappear */
2628                         pvt = iaxs[callno];
2629                         break;
2630                 case JB_INTERP:
2631                 {
2632                         struct ast_frame af = { 0, };
2633                         
2634                         /* create an interpolation frame */
2635                         af.frametype = AST_FRAME_VOICE;
2636                         af.subclass = pvt->voiceformat;
2637                         af.samples  = frame.ms * 8;
2638                         af.src  = "IAX2 JB interpolation";
2639                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2640                         af.offset = AST_FRIENDLY_OFFSET;
2641                         
2642                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2643                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2644                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2645                                 iax2_queue_frame(callno, &af);
2646                                 /* iax2_queue_frame() could cause the call to disappear */
2647                                 pvt = iaxs[callno];
2648                         }
2649                 }
2650                         break;
2651                 case JB_DROP:
2652                         iax2_frame_free(frame.data);
2653                         break;
2654                 case JB_NOFRAME:
2655                 case JB_EMPTY:
2656                         /* do nothing */
2657                         break;
2658                 default:
2659                         /* shouldn't happen */
2660                         break;
2661                 }
2662         }
2663         if (pvt)
2664                 update_jbsched(pvt);
2665         ast_mutex_unlock(&iaxsl[callno]);
2666 }
2667
2668 static int get_from_jb(void *data)
2669 {
2670 #ifdef SCHED_MULTITHREADED
2671         if (schedule_action(__get_from_jb, data))
2672 #endif          
2673                 __get_from_jb(data);
2674         return 0;
2675 }
2676
2677 /*!
2678  * \note This function assumes fr->callno is locked
2679  *
2680  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2681  * was valid before calling it, it may no longer be valid after calling it.
2682  */
2683 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2684 {
2685         int type, len;
2686         int ret;
2687         int needfree = 0;
2688
2689         /* Attempt to recover wrapped timestamps */
2690         unwrap_timestamp(fr);
2691
2692         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2693         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2694                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2695         else {
2696 #if 0
2697                 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2698 #endif
2699                 fr->af.delivery = ast_tv(0,0);
2700         }
2701
2702         type = JB_TYPE_CONTROL;
2703         len = 0;
2704
2705         if(fr->af.frametype == AST_FRAME_VOICE) {
2706                 type = JB_TYPE_VOICE;
2707                 len = ast_codec_get_samples(&fr->af) / 8;
2708         } else if(fr->af.frametype == AST_FRAME_CNG) {
2709                 type = JB_TYPE_SILENCE;
2710         }
2711
2712         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2713                 if (tsout)
2714                         *tsout = fr->ts;
2715                 __do_deliver(fr);
2716                 return -1;
2717         }
2718
2719         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2720          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2721         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2722             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2723             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2724                 jb_frame frame;
2725
2726                 /* deliver any frames in the jb */
2727                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2728                         __do_deliver(frame.data);
2729                         /* __do_deliver() can make the call disappear */
2730                         if (!iaxs[fr->callno])
2731                                 return -1;
2732                 }
2733
2734                 jb_reset(iaxs[fr->callno]->jb);
2735
2736                 if (iaxs[fr->callno]->jbid > -1)
2737                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2738
2739                 iaxs[fr->callno]->jbid = -1;
2740
2741                 /* deliver this frame now */
2742                 if (tsout)
2743                         *tsout = fr->ts;
2744                 __do_deliver(fr);
2745                 return -1;
2746         }
2747
2748         /* insert into jitterbuffer */
2749         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2750         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2751                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2752         if (ret == JB_DROP) {
2753                 needfree++;
2754         } else if (ret == JB_SCHED) {
2755                 update_jbsched(iaxs[fr->callno]);
2756         }
2757         if (tsout)
2758                 *tsout = fr->ts;
2759         if (needfree) {
2760                 /* Free our iax frame */
2761                 iax2_frame_free(fr);
2762                 return -1;
2763         }
2764         return 0;
2765 }
2766
2767 static int iax2_transmit(struct iax_frame *fr)
2768 {
2769         /* Lock the queue and place this packet at the end */
2770         /* By setting this to 0, the network thread will send it for us, and
2771            queue retransmission if necessary */
2772         fr->sentyet = 0;
2773         AST_LIST_LOCK(&frame_queue);
2774         AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
2775         AST_LIST_UNLOCK(&frame_queue);
2776         /* Wake up the network and scheduler thread */
2777         if (netthreadid != AST_PTHREADT_NULL)
2778                 pthread_kill(netthreadid, SIGURG);
2779         signal_condition(&sched_lock, &sched_cond);
2780         return 0;
2781 }
2782
2783
2784
2785 static int iax2_digit_begin(struct ast_channel *c, char digit)
2786 {
2787         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2788 }
2789
2790 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2791 {
2792         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2793 }
2794
2795 static int iax2_sendtext(struct ast_channel *c, const char *text)
2796 {
2797         
2798         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2799                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2800 }
2801
2802 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2803 {
2804         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2805 }
2806
2807 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2808 {
2809         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2810 }
2811
2812 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2813 {
2814         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2815         ast_mutex_lock(&iaxsl[callno]);
2816         if (iaxs[callno])
2817                 iaxs[callno]->owner = newchan;
2818         else
2819                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2820         ast_mutex_unlock(&iaxsl[callno]);
2821         return 0;
2822 }
2823
2824 /*!
2825  * \note This function calls reg_source_db -> iax2_poke_peer -> find_callno,
2826  *       so do not call this with a pvt lock held.
2827  */
2828 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2829 {
2830         struct ast_variable *var;
2831         struct ast_variable *tmp;
2832         struct iax2_peer *peer=NULL;
2833         time_t regseconds = 0, nowtime;
2834         int dynamic=0;
2835
2836         if (peername)
2837                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2838         else {
2839                 char porta[25];
2840                 sprintf(porta, "%d", ntohs(sin->sin_port));
2841                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2842                 if (var) {
2843                         /* We'll need the peer name in order to build the structure! */
2844                         for (tmp = var; tmp; tmp = tmp->next) {
2845                                 if (!strcasecmp(tmp->name, "name"))
2846                                         peername = tmp->value;
2847                         }
2848                 }
2849         }
2850         if (!var)
2851                 return NULL;
2852
2853         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2854         
2855         if (!peer) {
2856                 ast_variables_destroy(var);
2857                 return NULL;
2858         }
2859
2860         for (tmp = var; tmp; tmp = tmp->next) {
2861                 /* Make sure it's not a user only... */
2862                 if (!strcasecmp(tmp->name, "type")) {
2863                         if (strcasecmp(tmp->value, "friend") &&
2864                             strcasecmp(tmp->value, "peer")) {
2865                                 /* Whoops, we weren't supposed to exist! */
2866                                 peer = peer_unref(peer);
2867                                 break;
2868                         } 
2869                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2870                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2871                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2872                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2873                 } else if (!strcasecmp(tmp->name, "port")) {
2874                         peer->addr.sin_port = htons(atoi(tmp->value));
2875                 } else if (!strcasecmp(tmp->name, "host")) {
2876                         if (!strcasecmp(tmp->value, "dynamic"))
2877                                 dynamic = 1;
2878                 }
2879         }
2880
2881         ast_variables_destroy(var);
2882
2883         if (!peer)
2884                 return NULL;
2885
2886         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2887                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2888                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2889                         peer->expire = ast_sched_replace(peer->expire, sched, 
2890                                 (global_rtautoclear) * 1000, expire_registry, (void *) peer->name);
2891                 }
2892                 ao2_link(peers, peer_ref(peer));
2893                 if (ast_test_flag(peer, IAX_DYNAMIC))
2894                         reg_source_db(peer);
2895         } else {
2896                 ast_set_flag(peer, IAX_TEMPONLY);       
2897         }
2898
2899         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2900                 time(&nowtime);
2901                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2902                         memset(&peer->addr, 0, sizeof(peer->addr));
2903                         realtime_update_peer(peer->name, &peer->addr, 0);
2904                         ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2905                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2906                 }
2907                 else {
2908                         ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2909                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2910                 }
2911         }
2912
2913         return peer;
2914 }
2915
2916 static struct iax2_user *realtime_user(const char *username)
2917 {
2918         struct ast_variable *var;
2919         struct ast_variable *tmp;
2920         struct iax2_user *user=NULL;
2921
2922         var = ast_load_realtime("iaxusers", "name", username, NULL);
2923         if (!var)
2924                 return NULL;
2925
2926         tmp = var;
2927         while(tmp) {
2928                 /* Make sure it's not a peer only... */
2929                 if (!strcasecmp(tmp->name, "type")) {
2930                         if (strcasecmp(tmp->value, "friend") &&
2931                             strcasecmp(tmp->value, "user")) {
2932                                 return NULL;
2933                         } 
2934                 }
2935                 tmp = tmp->next;
2936         }
2937
2938         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2939
2940         ast_variables_destroy(var);
2941
2942         if (!user)
2943                 return NULL;
2944
2945         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2946                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2947                 ao2_link(users, user_ref(user));
2948         } else {
2949                 ast_set_flag(user, IAX_TEMPONLY);       
2950         }
2951
2952         return user;
2953 }
2954
2955 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2956 {
2957         char port[10];
2958         char regseconds[20];
2959         
2960         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2961         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2962         ast_update_realtime("iaxpeers", "name", peername, 
2963                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
2964                 "regseconds", regseconds, NULL);
2965 }
2966
2967 struct create_addr_info {
2968         int capability;
2969         unsigned int flags;
2970         int maxtime;
2971         int encmethods;
2972         int found;
2973         int sockfd;
2974         int adsi;
2975         char username[80];
2976         char secret[80];
2977         char outkey[80];
2978         char timezone[80];
2979         char prefs[32];
2980         char context[AST_MAX_CONTEXT];
2981         char peercontext[AST_MAX_CONTEXT];
2982         char mohinterpret[MAX_MUSICCLASS];
2983         char mohsuggest[MAX_MUSICCLASS];
2984 };
2985
2986 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2987 {
2988         struct iax2_peer *peer;
2989         int res = -1;
2990
2991         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2992         cai->sockfd = defaultsockfd;
2993         cai->maxtime = 0;
2994         sin->sin_family = AF_INET;
2995
2996         if (!(peer = find_peer(peername, 1))) {
2997                 cai->found = 0;
2998                 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
2999                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
3000                         return -1;
3001                 }
3002                 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
3003                 /* use global iax prefs for unknown peer/user */
3004                 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
3005                 return 0;
3006         }
3007
3008         cai->found = 1;
3009         
3010         /* if the peer has no address (current or default), return failure */
3011         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr))
3012                 goto return_unref;
3013
3014         /* if the peer is being monitored and is currently unreachable, return failure */
3015         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0)))
3016                 goto return_unref;
3017
3018         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
3019         cai->maxtime = peer->maxms;
3020         cai->capability = peer->capability;
3021         cai->encmethods = peer->encmethods;
3022         cai->sockfd = peer->sockfd;
3023         cai->adsi = peer->adsi;
3024         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
3025         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
3026         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
3027         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
3028         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
3029         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
3030         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
3031         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
3032         if (ast_strlen_zero(peer->dbsecret)) {
3033                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
3034         } else {
3035                 char *family;
3036                 char *key = NULL;
3037
3038                 family = ast_strdupa(peer->dbsecret);
3039                 key = strchr(family, '/');
3040                 if (key)
3041                         *key++ = '\0';
3042                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
3043                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
3044                         goto return_unref;
3045                 }
3046         }
3047
3048         if (peer->addr.sin_addr.s_addr) {
3049                 sin->sin_addr = peer->addr.sin_addr;
3050                 sin->sin_port = peer->addr.sin_port;
3051         } else {
3052                 sin->sin_addr = peer->defaddr.sin_addr;
3053                 sin->sin_port = peer->defaddr.sin_port;
3054         }
3055
3056         res = 0;
3057
3058 return_unref:
3059         peer_unref(peer);
3060
3061         return res;
3062 }
3063
3064 static void __auto_congest(void *nothing)
3065 {
3066         int callno = PTR_TO_CALLNO(nothing);
3067         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
3068         ast_mutex_lock(&iaxsl[callno]);
3069         if (iaxs[callno]) {
3070                 iaxs[callno]->initid = -1;
3071                 iax2_queue_frame(callno, &f);
3072                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
3073         }
3074         ast_mutex_unlock(&iaxsl[callno]);
3075 }
3076
3077 static int auto_congest(void *data)
3078 {
3079 #ifdef SCHED_MULTITHREADED
3080         if (schedule_action(__auto_congest, data))
3081 #endif          
3082                 __auto_congest(data);
3083         return 0;
3084 }
3085
3086 static unsigned int iax2_datetime(const char *tz)
3087 {
3088         struct timeval t = ast_tvnow();
3089         struct ast_tm tm;
3090         unsigned int tmp;
3091         ast_localtime(&t, &tm, ast_strlen_zero(tz) ? NULL : tz);
3092         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
3093         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
3094         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
3095         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
3096         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
3097         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
3098         return tmp;
3099 }
3100
3101 struct parsed_dial_string {
3102         char *username;
3103         char *password;
3104         char *key;
3105         char *peer;
3106         char *port;
3107         char *exten;
3108         char *context;
3109         char *options;
3110 };
3111
3112 /*!
3113  * \brief Parses an IAX dial string into its component parts.
3114  * \param data the string to be parsed
3115  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
3116  * \return nothing
3117  *
3118  * This function parses the string and fills the structure
3119  * with pointers to its component parts. The input string
3120  * will be modified.
3121  *
3122  * \note This function supports both plaintext passwords and RSA
3123  * key names; if the password string is formatted as '[keyname]',
3124  * then the keyname will be placed into the key field, and the
3125  * password field will be set to NULL.
3126  *
3127  * \note The dial string format is:
3128  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
3129  */
3130 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
3131 {
3132         if (ast_strlen_zero(data))
3133                 return;
3134
3135         pds->peer = strsep(&data, "/");
3136         pds->exten = strsep(&data, "/");
3137         pds->options = data;
3138
3139         if (pds->exten) {
3140                 data = pds->exten;
3141                 pds->exten = strsep(&data, "@");
3142                 pds->context = data;
3143         }
3144
3145         if (strchr(pds->peer, '@')) {
3146                 data = pds->peer;
3147                 pds->username = strsep(&data, "@");
3148                 pds->peer = data;
3149         }
3150
3151         if (pds->username) {
3152                 data = pds->username;
3153                 pds->username = strsep(&data, ":");
3154                 pds->password = data;
3155         }
3156
3157         data = pds->peer;
3158         pds->peer = strsep(&data, ":");
3159         pds->port = data;
3160
3161         /* check for a key name wrapped in [] in the secret position, if found,
3162            move it to the key field instead
3163         */
3164         if (pds->password && (pds->password[0] == '[')) {
3165                 pds->key = ast_strip_quoted(pds->password, "[", "]");
3166                 pds->password = NULL;
3167         }
3168 }
3169
3170 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
3171 {
3172         struct sockaddr_in sin;
3173         char *l=NULL, *n=NULL, *tmpstr;
3174         struct iax_ie_data ied;
3175         char *defaultrdest = "s";
3176         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3177         struct parsed_dial_string pds;
3178         struct create_addr_info cai;
3179         struct ast_var_t *var;
3180         struct ast_datastore *variablestore = ast_channel_datastore_find(c, &iax2_variable_datastore_info, NULL);
3181         const char* osp_token_ptr;
3182         unsigned int osp_token_length;
3183         unsigned char osp_block_index;
3184         unsigned int osp_block_length;
3185         unsigned char osp_buffer[256];
3186
3187         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
3188                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
3189                 return -1;
3190         }
3191
3192         memset(&cai, 0, sizeof(cai));
3193         cai.encmethods = iax2_encryption;
3194
3195         memset(&pds, 0, sizeof(pds));
3196         tmpstr = ast_strdupa(dest);
3197         parse_dial_string(tmpstr, &pds);
3198
3199         if (!pds.exten)
3200                 pds.exten = defaultrdest;
3201
3202         if (create_addr(pds.peer, &sin, &cai)) {
3203                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
3204                 return -1;
3205         }
3206
3207         if (!pds.username && !ast_strlen_zero(cai.username))
3208                 pds.username = cai.username;
3209         if (!pds.password && !ast_strlen_zero(cai.secret))
3210                 pds.password = cai.secret;
3211         if (!pds.key && !ast_strlen_zero(cai.outkey))
3212                 pds.key = cai.outkey;
3213         if (!pds.context && !ast_strlen_zero(cai.peercontext))
3214                 pds.context = cai.peercontext;
3215