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