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