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