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