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