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