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