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