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