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);