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