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