01d42b57fa20db5e4554b0cef4e7641d680a6814
[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         }
1460 }
1461
1462 static void network_change_stasis_unsubscribe(void)
1463 {
1464         network_change_sub = stasis_unsubscribe_and_join(network_change_sub);
1465 }
1466
1467 static void acl_change_stasis_subscribe(void)
1468 {
1469         if (!acl_change_sub) {
1470                 acl_change_sub = stasis_subscribe(ast_security_topic(),
1471                         acl_change_stasis_cb, NULL);
1472         }
1473 }
1474
1475 static void acl_change_stasis_unsubscribe(void)
1476 {
1477         acl_change_sub = stasis_unsubscribe_and_join(acl_change_sub);
1478 }
1479
1480 static int network_change_sched_cb(const void *data)
1481 {
1482         struct iax2_registry *reg;
1483         network_change_sched_id = -1;
1484         AST_LIST_LOCK(&registrations);
1485         AST_LIST_TRAVERSE(&registrations, reg, entry) {
1486                 iax2_do_register(reg);
1487         }
1488         AST_LIST_UNLOCK(&registrations);
1489
1490         return 0;
1491 }
1492
1493 static void network_change_stasis_cb(void *data, struct stasis_subscription *sub,
1494         struct stasis_message *message)
1495 {
1496         /* This callback is only concerned with network change messages from the system topic. */
1497         if (stasis_message_type(message) != ast_network_change_type()) {
1498                 return;
1499         }
1500
1501         ast_verb(1, "IAX, got a network change message, renewing all IAX registrations.\n");
1502         if (network_change_sched_id == -1) {
1503                 network_change_sched_id = iax2_sched_add(sched, 1000, network_change_sched_cb, NULL);
1504         }
1505 }
1506
1507 static void acl_change_stasis_cb(void *data, struct stasis_subscription *sub,
1508         struct stasis_message *message)
1509 {
1510         if (stasis_message_type(message) != ast_named_acl_change_type()) {
1511                 return;
1512         }
1513
1514         ast_log(LOG_NOTICE, "Reloading chan_iax2 in response to ACL change event.\n");
1515         reload_config(1);
1516 }
1517
1518 static const struct ast_datastore_info iax2_variable_datastore_info = {
1519         .type = "IAX2_VARIABLE",
1520         .duplicate = iax2_dup_variable_datastore,
1521         .destroy = iax2_free_variable_datastore,
1522 };
1523
1524 static void *iax2_dup_variable_datastore(void *old)
1525 {
1526         AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1527         struct ast_var_t *oldvar, *newvar;
1528
1529         newlist = ast_calloc(sizeof(*newlist), 1);
1530         if (!newlist) {
1531                 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1532                 return NULL;
1533         }
1534
1535         AST_LIST_HEAD_INIT(newlist);
1536         AST_LIST_LOCK(oldlist);
1537         AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1538                 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1539                 if (newvar)
1540                         AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1541                 else
1542                         ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1543         }
1544         AST_LIST_UNLOCK(oldlist);
1545         return newlist;
1546 }
1547
1548 static void iax2_free_variable_datastore(void *old)
1549 {
1550         AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1551         struct ast_var_t *oldvar;
1552
1553         AST_LIST_LOCK(oldlist);
1554         while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1555                 ast_free(oldvar);
1556         }
1557         AST_LIST_UNLOCK(oldlist);
1558         AST_LIST_HEAD_DESTROY(oldlist);
1559         ast_free(oldlist);
1560 }
1561
1562
1563 /* WARNING: insert_idle_thread should only ever be called within the
1564  * context of an iax2_process_thread() thread.
1565  */
1566 static void insert_idle_thread(struct iax2_thread *thread)
1567 {
1568         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1569                 AST_LIST_LOCK(&dynamic_list);
1570                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1571                 AST_LIST_UNLOCK(&dynamic_list);
1572         } else {
1573                 AST_LIST_LOCK(&idle_list);
1574                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1575                 AST_LIST_UNLOCK(&idle_list);
1576         }
1577
1578         return;
1579 }
1580
1581 static struct iax2_thread *find_idle_thread(void)
1582 {
1583         struct iax2_thread *thread = NULL;
1584
1585         /* Pop the head of the idle list off */
1586         AST_LIST_LOCK(&idle_list);
1587         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1588         AST_LIST_UNLOCK(&idle_list);
1589
1590         /* If we popped a thread off the idle list, just return it */
1591         if (thread) {
1592                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1593                 return thread;
1594         }
1595
1596         /* Pop the head of the dynamic list off */
1597         AST_LIST_LOCK(&dynamic_list);
1598         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1599         AST_LIST_UNLOCK(&dynamic_list);
1600
1601         /* If we popped a thread off the dynamic list, just return it */
1602         if (thread) {
1603                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1604                 return thread;
1605         }
1606
1607         /* If we can't create a new dynamic thread for any reason, return no thread at all */
1608         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1609                 return NULL;
1610
1611         /* Set default values */
1612         ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1613         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1614         thread->type = IAX_THREAD_TYPE_DYNAMIC;
1615
1616         /* Initialize lock and condition */
1617         ast_mutex_init(&thread->lock);
1618         ast_cond_init(&thread->cond, NULL);
1619         ast_mutex_init(&thread->init_lock);
1620         ast_cond_init(&thread->init_cond, NULL);
1621         ast_mutex_lock(&thread->init_lock);
1622
1623         /* Create thread and send it on it's way */
1624         if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1625                 ast_cond_destroy(&thread->cond);
1626                 ast_mutex_destroy(&thread->lock);
1627                 ast_mutex_unlock(&thread->init_lock);
1628                 ast_cond_destroy(&thread->init_cond);
1629                 ast_mutex_destroy(&thread->init_lock);
1630                 ast_free(thread);
1631                 return NULL;
1632         }
1633
1634         /* this thread is not processing a full frame (since it is idle),
1635            so ensure that the field for the full frame call number is empty */
1636         memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1637
1638         /* Wait for the thread to be ready before returning it to the caller */
1639         ast_cond_wait(&thread->init_cond, &thread->init_lock);
1640
1641         /* Done with init_lock */
1642         ast_mutex_unlock(&thread->init_lock);
1643
1644         return thread;
1645 }
1646
1647 #ifdef SCHED_MULTITHREADED
1648 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1649 {
1650         struct iax2_thread *thread;
1651         static time_t lasterror;
1652         time_t t;
1653
1654         thread = find_idle_thread();
1655         if (thread != NULL) {
1656                 thread->schedfunc = func;
1657                 thread->scheddata = data;
1658                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1659 #ifdef DEBUG_SCHED_MULTITHREAD
1660                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1661 #endif
1662                 signal_condition(&thread->lock, &thread->cond);
1663                 return 0;
1664         }
1665         time(&t);
1666         if (t != lasterror) {
1667                 lasterror = t;
1668                 ast_debug(1, "Out of idle IAX2 threads for scheduling! (%s)\n", funcname);
1669         }
1670
1671         return -1;
1672 }
1673 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1674 #endif
1675
1676 static int iax2_sched_replace(int id, struct ast_sched_context *con, int when,
1677                 ast_sched_cb callback, const void *data)
1678 {
1679         return ast_sched_replace(id, con, when, callback, data);
1680 }
1681
1682 static int iax2_sched_add(struct ast_sched_context *con, int when,
1683                 ast_sched_cb callback, const void *data)
1684 {
1685         return ast_sched_add(con, when, callback, data);
1686 }
1687
1688 /*
1689  * \brief Acquire the iaxsl[callno] if call exists and not having ongoing hangup.
1690  * \param callno Call number to lock.
1691  * \return 0 If call disappeared or has ongoing hangup procedure. 1 If call found and mutex is locked.
1692  */
1693 static int iax2_lock_callno_unless_destroyed(int callno)
1694 {
1695         ast_mutex_lock(&iaxsl[callno]);
1696
1697         /* We acquired the lock; but the call was already destroyed (we came after full hang up procedures)
1698          * or destroy initiated (in middle of hang up procedure. */
1699         if (!iaxs[callno] || iaxs[callno]->destroy_initiated) {
1700                 ast_debug(3, "I wanted to lock callno %d, but it is dead or going to die.\n", callno);
1701                 ast_mutex_unlock(&iaxsl[callno]);
1702                 return 0;
1703         }
1704
1705         /* Lock acquired, and callno is alive and kicking. */
1706         return 1;
1707 }
1708
1709 static int send_ping(const void *data);
1710
1711 static void __send_ping(const void *data)
1712 {
1713         int callno = PTR_TO_CALLNO(data);
1714
1715         if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1716                 ast_debug(3, "Hangup initiated on call %d, aborting __send_ping\n", callno);
1717                 return;
1718         }
1719
1720         /* Mark pingid as invalid scheduler id. */
1721         iaxs[callno]->pingid = -1;
1722
1723         /* callno is now locked. */
1724         if (iaxs[callno]->peercallno) {
1725                 /* Send PING packet. */
1726                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1727
1728                 /* Schedule sending next ping. */
1729                 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1730         }
1731
1732         ast_mutex_unlock(&iaxsl[callno]);
1733 }
1734
1735 static int send_ping(const void *data)
1736 {
1737 #ifdef SCHED_MULTITHREADED
1738         if (schedule_action(__send_ping, data))
1739 #endif
1740                 __send_ping(data);
1741
1742         return 0;
1743 }
1744
1745 static void encmethods_to_str(int e, struct ast_str **buf)
1746 {
1747         ast_str_set(buf, 0, "(");
1748         if (e & IAX_ENCRYPT_AES128) {
1749                 ast_str_append(buf, 0, "aes128");
1750         }
1751         if (e & IAX_ENCRYPT_KEYROTATE) {
1752                 ast_str_append(buf, 0, ",keyrotate");
1753         }
1754         if (ast_str_strlen(*buf) > 1) {
1755                 ast_str_append(buf, 0, ")");
1756         } else {
1757                 ast_str_set(buf, 0, "No");
1758         }
1759 }
1760
1761 static int get_encrypt_methods(const char *s)
1762 {
1763         int e;
1764         if (!strcasecmp(s, "aes128"))
1765                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1766         else if (ast_true(s))
1767                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1768         else
1769                 e = 0;
1770         return e;
1771 }
1772
1773 static int send_lagrq(const void *data);
1774
1775 static void __send_lagrq(const void *data)
1776 {
1777         int callno = PTR_TO_CALLNO(data);
1778
1779         if (iax2_lock_callno_unless_destroyed(callno) == 0) {
1780                 ast_debug(3, "Hangup initiated on call %d, aborting __send_lagrq\n", callno);
1781                 return;
1782         }
1783
1784         /* Mark lagid as invalid scheduler id. */
1785         iaxs[callno]->lagid = -1;
1786
1787         /* callno is now locked. */
1788         if (iaxs[callno]->peercallno) {
1789                 /* Send LAGRQ packet. */
1790                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1791
1792                 /* Schedule sending next lagrq. */
1793                 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1794         }
1795
1796         ast_mutex_unlock(&iaxsl[callno]);
1797 }
1798
1799 static int send_lagrq(const void *data)
1800 {
1801 #ifdef SCHED_MULTITHREADED
1802         if (schedule_action(__send_lagrq, data))
1803 #endif
1804                 __send_lagrq(data);
1805         return 0;
1806 }
1807
1808 static unsigned char compress_subclass(iax2_format subclass)
1809 {
1810         int x;
1811         int power=-1;
1812         /* If it's 64 or smaller, just return it */
1813         if (subclass < IAX_FLAG_SC_LOG)
1814                 return subclass;
1815         /* Otherwise find its power */
1816         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1817                 if (subclass & (1LL << x)) {
1818                         if (power > -1) {
1819                                 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
1820                                 return 0;
1821                         } else
1822                                 power = x;
1823                 }
1824         }
1825         return power | IAX_FLAG_SC_LOG;
1826 }
1827
1828 static iax2_format uncompress_subclass(unsigned char csub)
1829 {
1830         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1831         if (csub & IAX_FLAG_SC_LOG) {
1832                 /* special case for 'compressed' -1 */
1833                 if (csub == 0xff)
1834                         return -1;
1835                 else
1836                         return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1837         }
1838         else
1839                 return csub;
1840 }
1841
1842 static struct ast_format *codec_choose_from_prefs(struct iax2_codec_pref *pref, struct ast_format_cap *cap)
1843 {
1844         int x;
1845         struct ast_format *found_format = NULL;
1846
1847         for (x = 0; x < ARRAY_LEN(pref->order); ++x) {
1848                 struct ast_format *pref_format;
1849                 uint64_t pref_bitfield;
1850
1851                 pref_bitfield = iax2_codec_pref_order_value_to_format_bitfield(pref->order[x]);
1852                 if (!pref_bitfield) {
1853                         break;
1854                 }
1855
1856                 pref_format = ast_format_compatibility_bitfield2format(pref_bitfield);
1857                 if (!pref_format) {
1858                         /* The bitfield is not associated with any format. */
1859                         continue;
1860                 }
1861                 found_format = ast_format_cap_get_compatible_format(cap, pref_format);
1862                 if (found_format) {
1863                         break;
1864                 }
1865         }
1866
1867         if (found_format && (ast_format_get_type(found_format) == AST_MEDIA_TYPE_AUDIO)) {
1868                 return found_format;
1869         }
1870
1871         ast_debug(4, "Could not find preferred codec - Returning zero codec.\n");
1872         ao2_cleanup(found_format);
1873         return NULL;
1874 }
1875
1876 static iax2_format iax2_codec_choose(struct iax2_codec_pref *pref, iax2_format formats)
1877 {
1878         struct ast_format_cap *cap;
1879         struct ast_format *tmpfmt;
1880         iax2_format format = 0;
1881
1882         if ((cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
1883                 iax2_format_compatibility_bitfield2cap(formats, cap);
1884                 tmpfmt = codec_choose_from_prefs(pref, cap);
1885                 if (!tmpfmt) {
1886                         ao2_ref(cap, -1);
1887                         return 0;
1888                 }
1889
1890                 format = ast_format_compatibility_format2bitfield(tmpfmt);
1891                 ao2_ref(tmpfmt, -1);
1892                 ao2_ref(cap, -1);
1893         }
1894
1895         return format;
1896 }
1897
1898 const char *iax2_getformatname(iax2_format format)
1899 {
1900         struct ast_format *tmpfmt;
1901
1902         tmpfmt = ast_format_compatibility_bitfield2format(format);
1903         if (!tmpfmt) {
1904                 return "Unknown";
1905         }
1906
1907         return ast_format_get_name(tmpfmt);
1908 }
1909
1910 static const char *iax2_getformatname_multiple(iax2_format format, struct ast_str **codec_buf)
1911 {
1912         struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1913
1914         if (!cap) {
1915                 return "(Nothing)";
1916         }
1917         iax2_format_compatibility_bitfield2cap(format, cap);
1918         ast_format_cap_get_names(cap, codec_buf);
1919         ao2_ref(cap, -1);
1920
1921         return ast_str_buffer(*codec_buf);
1922 }
1923
1924 static int iax2_parse_allow_disallow(struct iax2_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
1925 {
1926         int res, i;
1927         struct ast_format_cap *cap;
1928
1929         /* We want to add the formats to the cap in the preferred order */
1930         cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
1931         if (!cap || iax2_codec_pref_to_cap(pref, cap)) {
1932                 ao2_cleanup(cap);
1933                 return 1;
1934         }
1935
1936         res = ast_format_cap_update_by_allow_disallow(cap, list, allowing);
1937
1938         /* Adjust formats bitfield and pref list to match. */
1939         *formats = iax2_format_compatibility_cap2bitfield(cap);
1940         iax2_codec_pref_remove_missing(pref, *formats);
1941
1942         for (i = 0; i < ast_format_cap_count(cap); i++) {
1943                 struct ast_format *fmt = ast_format_cap_get_format(cap, i);
1944
1945                 iax2_codec_pref_append(pref, fmt, ast_format_cap_get_format_framing(cap, fmt));
1946                 ao2_ref(fmt, -1);
1947         }
1948
1949         ao2_ref(cap, -1);
1950
1951         return res;
1952 }
1953
1954 /*!
1955  * \note The only member of the peer passed here guaranteed to be set is the name field
1956  */
1957 static int peer_hash_cb(const void *obj, const int flags)
1958 {
1959         const struct iax2_peer *peer = obj;
1960         const char *name = obj;
1961
1962         return ast_str_hash(flags & OBJ_KEY ? name : peer->name);
1963 }
1964
1965 /*!
1966  * \note The only member of the peer passed here guaranteed to be set is the name field
1967  */
1968 static int peer_cmp_cb(void *obj, void *arg, int flags)
1969 {
1970         struct iax2_peer *peer = obj, *peer2 = arg;
1971         const char *name = arg;
1972
1973         return !strcmp(peer->name, flags & OBJ_KEY ? name : peer2->name) ?
1974                         CMP_MATCH | CMP_STOP : 0;
1975 }
1976
1977 /*!
1978  * \note The only member of the user passed here guaranteed to be set is the name field
1979  */
1980 static int user_hash_cb(const void *obj, const int flags)
1981 {
1982         const struct iax2_user *user = obj;
1983         const char *name = obj;
1984
1985         return ast_str_hash(flags & OBJ_KEY ? name : user->name);
1986 }
1987
1988 /*!
1989  * \note The only member of the user passed here guaranteed to be set is the name field
1990  */
1991 static int user_cmp_cb(void *obj, void *arg, int flags)
1992 {
1993         struct iax2_user *user = obj, *user2 = arg;
1994         const char *name = arg;
1995
1996         return !strcmp(user->name, flags & OBJ_KEY ? name : user2->name) ?
1997                         CMP_MATCH | CMP_STOP : 0;
1998 }
1999
2000 /*!
2001  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
2002  *       so do not call it with a pvt lock held.
2003  */
2004 static struct iax2_peer *find_peer(const char *name, int realtime)
2005 {
2006         struct iax2_peer *peer = NULL;
2007
2008         peer = ao2_find(peers, name, OBJ_KEY);
2009
2010         /* Now go for realtime if applicable */
2011         if (!peer && realtime) {
2012                 peer = realtime_peer(name, NULL);
2013         }
2014         return peer;
2015 }
2016
2017 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
2018 {
2019         ao2_ref(peer, +1);
2020         return peer;
2021 }
2022
2023 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
2024 {
2025         ao2_ref(peer, -1);
2026         return NULL;
2027 }
2028
2029 static struct iax2_user *find_user(const char *name)
2030 {
2031         return ao2_find(users, name, OBJ_KEY);
2032 }
2033
2034 static inline struct iax2_user *user_unref(struct iax2_user *user)
2035 {
2036         ao2_ref(user, -1);
2037         return NULL;
2038 }
2039
2040 static int iax2_getpeername(struct ast_sockaddr addr, char *host, int len)
2041 {
2042         struct iax2_peer *peer = NULL;
2043         int res = 0;
2044         struct ao2_iterator i;
2045
2046         i = ao2_iterator_init(peers, 0);
2047         while ((peer = ao2_iterator_next(&i))) {
2048
2049                 if (!ast_sockaddr_cmp(&peer->addr, &addr)) {
2050                         ast_copy_string(host, peer->name, len);
2051                         peer_unref(peer);
2052                         res = 1;
2053                         break;
2054                 }
2055                 peer_unref(peer);
2056         }
2057         ao2_iterator_destroy(&i);
2058
2059         if (!peer) {
2060                 peer = realtime_peer(NULL, &addr);
2061                 if (peer) {
2062                         ast_copy_string(host, peer->name, len);
2063                         peer_unref(peer);
2064                         res = 1;
2065                 }
2066         }
2067
2068         return res;
2069 }
2070
2071 /* Call AST_SCHED_DEL on a scheduled task if it is found in scheduler. */
2072 static int iax2_delete_from_sched(const void* data)
2073 {
2074         int sched_id = (int)(long)data;
2075
2076         AST_SCHED_DEL(sched, sched_id);
2077
2078         return 0;
2079 }
2080
2081 /*!\note Assumes the lock on the pvt is already held, when
2082  * iax2_destroy_helper() is called. */
2083 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
2084 {
2085         /* Decrement AUTHREQ count if needed */
2086         if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
2087                 struct iax2_user *user;
2088
2089                 user = ao2_find(users, pvt->username, OBJ_KEY);
2090                 if (user) {
2091                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
2092                         user_unref(user);
2093                 }
2094
2095                 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
2096         }
2097
2098
2099         /* Mark call destroy initiated flag. */
2100         pvt->destroy_initiated = 1;
2101
2102         /*
2103          * Schedule deleting the scheduled (but didn't run yet) PINGs or LAGRQs.
2104          * Already running tasks will be terminated because of destroy_initiated.
2105          *
2106          * Don't call AST_SCHED_DEL from this thread for pingid and lagid because
2107          * it leads to a deadlock between the scheduler thread callback locking
2108          * the callno mutex and this thread which holds the callno mutex one or
2109          * more times.  It is better to have another thread delete the scheduled
2110          * callbacks which doesn't lock the callno mutex.
2111          */
2112         iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->pingid);
2113         iax2_sched_add(sched, 0, iax2_delete_from_sched, (void*)(long)pvt->lagid);
2114
2115         pvt->pingid = -1;
2116         pvt->lagid = -1;
2117
2118         AST_SCHED_DEL(sched, pvt->autoid);
2119         AST_SCHED_DEL(sched, pvt->authid);
2120         AST_SCHED_DEL(sched, pvt->initid);
2121         AST_SCHED_DEL(sched, pvt->jbid);
2122         AST_SCHED_DEL(sched, pvt->keyrotateid);
2123 }
2124
2125 static void iax2_frame_free(struct iax_frame *fr)
2126 {
2127         AST_SCHED_DEL(sched, fr->retrans);
2128         iax_frame_free(fr);
2129 }
2130
2131 static int scheduled_destroy(const void *vid)
2132 {
2133         unsigned short callno = PTR_TO_CALLNO(vid);
2134         ast_mutex_lock(&iaxsl[callno]);
2135         if (iaxs[callno]) {
2136                 ast_debug(1, "Really destroying %d now...\n", callno);
2137                 iax2_destroy(callno);
2138         }
2139         ast_mutex_unlock(&iaxsl[callno]);
2140         return 0;
2141 }
2142
2143 static void free_signaling_queue_entry(struct signaling_queue_entry *s)
2144 {
2145         if (s->f.datalen) {
2146                 ast_free(s->f.data.ptr);
2147         }
2148         ast_free(s);
2149 }
2150
2151 /*! \brief This function must be called once we are sure the other side has
2152  *  given us a call number.  All signaling is held here until that point. */
2153 static void send_signaling(struct chan_iax2_pvt *pvt)
2154 {
2155         struct signaling_queue_entry *s = NULL;
2156
2157         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2158                 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
2159                 free_signaling_queue_entry(s);
2160         }
2161         pvt->hold_signaling = 0;
2162 }
2163
2164 /*! \brief All frames other than that of type AST_FRAME_IAX must be held until
2165  *  we have received a destination call number. */
2166 static int queue_signalling(struct chan_iax2_pvt *pvt, struct ast_frame *f)
2167 {
2168         struct signaling_queue_entry *qe;
2169
2170         if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
2171                 return 1; /* do not queue this frame */
2172         } else if (!(qe = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
2173                 return -1;  /* out of memory */
2174         }
2175
2176         /* copy ast_frame into our queue entry */
2177         qe->f = *f;
2178         if (qe->f.datalen) {
2179                 /* if there is data in this frame copy it over as well */
2180                 if (!(qe->f.data.ptr = ast_malloc(qe->f.datalen))) {
2181                         free_signaling_queue_entry(qe);
2182                         return -1;
2183                 }
2184                 memcpy(qe->f.data.ptr, f->data.ptr, qe->f.datalen);
2185         }
2186         AST_LIST_INSERT_TAIL(&pvt->signaling_queue, qe, next);
2187
2188         return 0;
2189 }
2190
2191 static void pvt_destructor(void *obj)
2192 {
2193         struct chan_iax2_pvt *pvt = obj;
2194         struct iax_frame *cur = NULL;
2195         struct signaling_queue_entry *s = NULL;
2196
2197         ast_mutex_lock(&iaxsl[pvt->callno]);
2198
2199         iax2_destroy_helper(pvt);
2200
2201         sched_delay_remove(&pvt->addr, pvt->callno_entry);
2202         pvt->callno_entry = 0;
2203
2204         /* Already gone */
2205         ast_set_flag64(pvt, IAX_ALREADYGONE);
2206
2207         AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
2208                 /* Cancel any pending transmissions */
2209                 cur->retries = -1;
2210         }
2211
2212         ast_mutex_unlock(&iaxsl[pvt->callno]);
2213
2214         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
2215                 free_signaling_queue_entry(s);
2216         }
2217
2218         if (pvt->reg) {
2219                 pvt->reg->callno = 0;
2220         }
2221
2222         if (!pvt->owner) {
2223                 jb_frame frame;
2224                 if (pvt->vars) {
2225                     ast_variables_destroy(pvt->vars);
2226                     pvt->vars = NULL;
2227                 }
2228
2229                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
2230                         iax2_frame_free(frame.data);
2231                 }
2232
2233                 jb_destroy(pvt->jb);
2234                 ast_string_field_free_memory(pvt);
2235         }
2236 }
2237
2238 static struct chan_iax2_pvt *new_iax(struct ast_sockaddr *addr, const char *host)
2239 {
2240         struct chan_iax2_pvt *tmp;
2241         jb_conf jbconf;
2242
2243         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
2244                 return NULL;
2245         }
2246
2247         tmp->pingid = -1;
2248         tmp->lagid = -1;
2249         tmp->autoid = -1;
2250         tmp->authid = -1;
2251         tmp->initid = -1;
2252         tmp->keyrotateid = -1;
2253         tmp->jbid = -1;
2254
2255         if (ast_string_field_init(tmp, 32)) {
2256                 ao2_ref(tmp, -1);
2257                 tmp = NULL;
2258                 return NULL;
2259         }
2260
2261         tmp->prefs = prefs_global;
2262
2263         ast_string_field_set(tmp,exten, "s");
2264         ast_string_field_set(tmp,host, host);
2265
2266         tmp->jb = jb_new();
2267         jbconf.max_jitterbuf = maxjitterbuffer;
2268         jbconf.resync_threshold = resyncthreshold;
2269         jbconf.max_contig_interp = maxjitterinterps;
2270         jbconf.target_extra = jittertargetextra;
2271         jb_setconf(tmp->jb,&jbconf);
2272
2273         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
2274
2275         tmp->hold_signaling = 1;
2276         AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
2277
2278         return tmp;
2279 }
2280
2281 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
2282 {
2283         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
2284         if (new) {
2285                 size_t afdatalen = new->afdatalen;
2286                 memcpy(new, fr, sizeof(*new));
2287                 iax_frame_wrap(new, &fr->af);
2288                 new->afdatalen = afdatalen;
2289                 new->data = NULL;
2290                 new->datalen = 0;
2291                 new->direction = DIRECTION_INGRESS;
2292                 new->retrans = -1;
2293         }
2294         return new;
2295 }
2296 /* keep these defined in this order.  They are used in find_callno to
2297  * determine whether or not a new call number should be allowed. */
2298 enum {
2299         /* do not allow a new call number, only search ones in use for match */
2300         NEW_PREVENT = 0,
2301         /* search for match first, then allow a new one to be allocated */
2302         NEW_ALLOW = 1,
2303         /* do not search for match, force a new call number */
2304         NEW_FORCE = 2,
2305         /* do not search for match, force a new call number.  Signifies call number
2306          * has been calltoken validated */
2307         NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
2308 };
2309
2310 static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
2311 {
2312         if (!ast_sockaddr_cmp(&cur->addr, addr)) {
2313                 /* This is the main host */
2314                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
2315                          (check_dcallno ? dcallno == cur->callno : 1) ) {
2316                         /* That's us.  Be sure we keep track of the peer call number */
2317                         return 1;
2318                 }
2319         }
2320         if (!ast_sockaddr_cmp(&cur->transfer, addr) && cur->transferring) {
2321                 /* We're transferring */
2322                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
2323                         return 1;
2324         }
2325         return 0;
2326 }
2327
2328 static int make_trunk(unsigned short callno, int locked)
2329 {
2330         int x;
2331         int res= 0;
2332         callno_entry entry;
2333         if (iaxs[callno]->oseqno) {
2334                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
2335                 return -1;
2336         }
2337         if (callno >= TRUNK_CALL_START) {
2338                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
2339                 return -1;
2340         }
2341
2342         if (get_unused_callno(
2343                         CALLNO_TYPE_TRUNK,
2344                         CALLNO_ENTRY_IS_VALIDATED(iaxs[callno]->callno_entry),
2345                         &entry)) {
2346                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
2347                 return -1;
2348         }
2349
2350         x = CALLNO_ENTRY_GET_CALLNO(entry);
2351         ast_mutex_lock(&iaxsl[x]);
2352
2353         /*!
2354          * \note We delete these before switching the slot, because if
2355          * they fire in the meantime, they will generate a warning.
2356          */
2357         AST_SCHED_DEL(sched, iaxs[callno]->pingid);
2358         AST_SCHED_DEL(sched, iaxs[callno]->lagid);
2359         iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
2360         iaxs[x] = iaxs[callno];
2361         iaxs[x]->callno = x;
2362
2363         /* since we copied over the pvt from a different callno, make sure the old entry is replaced
2364          * before assigning the new one */
2365         if (iaxs[x]->callno_entry) {
2366                 iax2_sched_add(
2367                         sched,
2368                         MIN_REUSE_TIME * 1000,
2369                         replace_callno,
2370                         CALLNO_ENTRY_TO_PTR(iaxs[x]->callno_entry));
2371
2372         }
2373         iaxs[x]->callno_entry = entry;
2374
2375         iaxs[callno] = NULL;
2376         /* Update the two timers that should have been started */
2377         iaxs[x]->pingid = iax2_sched_add(sched,
2378                 ping_time * 1000, send_ping, (void *)(long)x);
2379         iaxs[x]->lagid = iax2_sched_add(sched,
2380                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
2381
2382         if (locked)
2383                 ast_mutex_unlock(&iaxsl[callno]);
2384         res = x;
2385         if (!locked)
2386                 ast_mutex_unlock(&iaxsl[x]);
2387
2388         /* We moved this call from a non-trunked to a trunked call */
2389         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
2390
2391         return res;
2392 }
2393
2394 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
2395 {
2396         if (!pvt->transfercallno) {
2397                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2398                 return;
2399         }
2400
2401         ao2_link(iax_transfercallno_pvts, pvt);
2402 }
2403
2404 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
2405 {
2406         if (!pvt->transfercallno) {
2407                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2408                 return;
2409         }
2410
2411         ao2_unlink(iax_transfercallno_pvts, pvt);
2412 }
2413 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
2414 {
2415         if (!pvt->peercallno) {
2416                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2417                 return;
2418         }
2419
2420         ao2_link(iax_peercallno_pvts, pvt);
2421 }
2422
2423 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
2424 {
2425         if (!pvt->peercallno) {
2426                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2427                 return;
2428         }
2429
2430         ao2_unlink(iax_peercallno_pvts, pvt);
2431 }
2432
2433 static int addr_range_delme_cb(void *obj, void *arg, int flags)
2434 {
2435         struct addr_range *lim = obj;
2436         lim->delme = 1;
2437         return 0;
2438 }
2439
2440 static int addr_range_hash_cb(const void *obj, const int flags)
2441 {
2442         const struct addr_range *lim = obj;
2443         return abs(ast_sockaddr_hash(&lim->ha.addr));
2444 }
2445
2446 static int addr_range_cmp_cb(void *obj, void *arg, int flags)
2447 {
2448         struct addr_range *lim1 = obj, *lim2 = arg;
2449         return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
2450                         !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
2451                         CMP_MATCH | CMP_STOP : 0;
2452 }
2453
2454 static int peercnt_hash_cb(const void *obj, const int flags)
2455 {
2456         const struct peercnt *peercnt = obj;
2457
2458         if (ast_sockaddr_isnull(&peercnt->addr)) {
2459                 return 0;
2460         }
2461         return ast_sockaddr_hash(&peercnt->addr);
2462 }
2463
2464 static int peercnt_cmp_cb(void *obj, void *arg, int flags)
2465 {
2466         struct peercnt *peercnt1 = obj, *peercnt2 = arg;
2467         return !ast_sockaddr_cmp_addr(&peercnt1->addr, &peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
2468 }
2469
2470 static int addr_range_match_address_cb(void *obj, void *arg, int flags)
2471 {
2472         struct addr_range *addr_range = obj;
2473         struct ast_sockaddr *addr = arg;
2474         struct ast_sockaddr tmp_addr;
2475
2476         ast_sockaddr_apply_netmask(addr, &addr_range->ha.netmask, &tmp_addr);
2477
2478         if (!ast_sockaddr_cmp_addr(&tmp_addr, &addr_range->ha.addr)) {
2479                 return CMP_MATCH | CMP_STOP;
2480         }
2481         return 0;
2482 }
2483
2484 /*!
2485  * \internal
2486  *
2487  * \brief compares addr to calltoken_ignores table to determine if validation is required.
2488  */
2489 static int calltoken_required(struct ast_sockaddr *addr, const char *name, int subclass)
2490 {
2491         struct addr_range *addr_range;
2492         struct iax2_peer *peer = NULL;
2493         struct iax2_user *user = NULL;
2494         /* if no username is given, check for guest accounts */
2495         const char *find = S_OR(name, "guest");
2496         int res = 1;  /* required by default */
2497         int optional = 0;
2498         enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2499         /* There are only two cases in which calltoken validation is not required.
2500          * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2501          *         the peer definition has not set the requirecalltoken option.
2502          * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2503          */
2504
2505         /* ----- Case 1 ----- */
2506         if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, addr))) {
2507                 ao2_ref(addr_range, -1);
2508                 optional = 1;
2509         }
2510
2511         /* ----- Case 2 ----- */
2512         if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2513                 calltoken_required = user->calltoken_required;
2514         } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, addr))) {
2515                 calltoken_required = user->calltoken_required;
2516         } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2517                 calltoken_required = peer->calltoken_required;
2518         } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, addr))) {
2519                 calltoken_required = peer->calltoken_required;
2520         }
2521
2522         if (peer) {
2523                 peer_unref(peer);
2524         }
2525         if (user) {
2526                 user_unref(user);
2527         }
2528
2529         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);
2530         if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2531                 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2532                 res = 0;
2533         }
2534
2535         return res;
2536 }
2537
2538 /*!
2539  * \internal
2540  *
2541  * \brief set peercnt callno limit.
2542  *
2543  * \details
2544  * First looks in custom definitions. If not found, global limit
2545  * is used.  Entries marked as reg already have
2546  * a custom limit set by a registration and are not modified.
2547  */
2548 static void set_peercnt_limit(struct peercnt *peercnt)
2549 {
2550         uint16_t limit = global_maxcallno;
2551         struct addr_range *addr_range;
2552         struct ast_sockaddr addr;
2553
2554         ast_sockaddr_copy(&addr, &peercnt->addr);
2555
2556         if (peercnt->reg && peercnt->limit) {
2557                 return; /* this peercnt has a custom limit set by a registration */
2558         }
2559
2560         if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &addr))) {
2561                 limit = addr_range->limit;
2562                 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_sockaddr_stringify(&addr));
2563                 ao2_ref(addr_range, -1);
2564         }
2565
2566         peercnt->limit = limit;
2567 }
2568
2569 /*!
2570  * \internal
2571  * \brief sets limits for all peercnts in table. done on reload to reflect changes in conf.
2572  */
2573 static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
2574 {
2575         struct peercnt *peercnt = obj;
2576
2577         set_peercnt_limit(peercnt);
2578         ast_debug(1, "Reset limits for peercnts table\n");
2579
2580         return 0;
2581 }
2582
2583 /*!
2584  * \internal
2585  * \brief returns match if delme is set.
2586  */
2587 static int prune_addr_range_cb(void *obj, void *arg, int flags)
2588 {
2589         struct addr_range *addr_range = obj;
2590
2591         return addr_range->delme ? CMP_MATCH : 0;
2592 }
2593
2594 /*!
2595  * \internal
2596  * \brief modifies peercnt entry in peercnts table. Used to set custom limit or mark a registered ip
2597  */
2598 static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
2599 {
2600         /* this function turns off and on custom callno limits set by peer registration */
2601         struct peercnt *peercnt;
2602         struct peercnt tmp;
2603
2604         ast_sockaddr_copy(&tmp.addr, sockaddr);
2605
2606         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2607                 peercnt->reg = reg;
2608                 if (limit) {
2609                         peercnt->limit = limit;
2610                 } else {
2611                         set_peercnt_limit(peercnt);
2612                 }
2613                 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_sockaddr_stringify_addr(sockaddr), peercnt->limit, peercnt->reg);
2614                 ao2_ref(peercnt, -1); /* decrement ref from find */
2615         }
2616 }
2617
2618 /*!
2619  * \internal
2620  * \brief adds an ip to the peercnts table, increments connection count if it already exists
2621  *
2622  * \details First searches for the address in the peercnts table.  If found
2623  * the current count is incremented.  If not found a new peercnt is allocated
2624  * and linked into the peercnts table with a call number count of 1.
2625  */
2626 static int peercnt_add(struct ast_sockaddr *addr)
2627 {
2628         struct peercnt *peercnt;
2629         int res = 0;
2630         struct peercnt tmp;
2631
2632         ast_sockaddr_copy(&tmp.addr, addr);
2633
2634         /* Reasoning for peercnts container lock:  Two identical ip addresses
2635          * could be added by different threads at the "same time". Without the container
2636          * lock, both threads could alloc space for the same object and attempt
2637          * to link to table.  With the lock, one would create the object and link
2638          * to table while the other would find the already created peercnt object
2639          * rather than creating a new one. */
2640         ao2_lock(peercnts);
2641         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2642                 ao2_lock(peercnt);
2643         } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2644                 ao2_lock(peercnt);
2645                 /* create and set defaults */
2646                 ast_sockaddr_copy(&peercnt->addr, addr);
2647                 set_peercnt_limit(peercnt);
2648                 /* guarantees it does not go away after unlocking table
2649                  * ao2_find automatically adds this */
2650                 ao2_link(peercnts, peercnt);
2651         } else {
2652                 ao2_unlock(peercnts);
2653                 return -1;
2654         }
2655
2656         /* check to see if the address has hit its callno limit.  If not increment cur. */
2657         if (peercnt->limit > peercnt->cur) {
2658                 peercnt->cur++;
2659                 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(addr));
2660         } else { /* max num call numbers for this peer has been reached! */
2661                 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_sockaddr_stringify_addr(addr));
2662                 res = -1;
2663         }
2664
2665         /* clean up locks and ref count */
2666         ao2_unlock(peercnt);
2667         ao2_unlock(peercnts);
2668         ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2669
2670         return res;
2671 }
2672
2673 /*!
2674  * \internal
2675  * \brief decrements a peercnts table entry
2676  */
2677 static void peercnt_remove(struct peercnt *peercnt)
2678 {
2679         struct ast_sockaddr addr;
2680
2681         ast_sockaddr_copy(&addr, &peercnt->addr);
2682
2683         /*
2684          * Container locked here since peercnt may be unlinked from
2685          * list.  If left unlocked, peercnt_add could try and grab this
2686          * entry from the table and modify it at the "same time" this
2687          * thread attemps to unlink it.
2688          */
2689         ao2_lock(peercnts);
2690         peercnt->cur--;
2691         ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_sockaddr_stringify_addr(&addr));
2692         /* if this was the last connection from the peer remove it from table */
2693         if (peercnt->cur == 0) {
2694                 ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2695         }
2696         ao2_unlock(peercnts);
2697 }
2698
2699 /*!
2700  * \internal
2701  * \brief called by scheduler to decrement object
2702  */
2703 static int peercnt_remove_cb(const void *obj)
2704 {
2705         struct peercnt *peercnt = (struct peercnt *) obj;
2706
2707         peercnt_remove(peercnt);
2708         ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2709
2710         return 0;
2711 }
2712
2713 /*!
2714  * \internal
2715  * \brief decrements peercnts connection count, finds by addr
2716  */
2717 static int peercnt_remove_by_addr(struct ast_sockaddr *addr)
2718 {
2719         struct peercnt *peercnt;
2720         struct peercnt tmp;
2721
2722         ast_sockaddr_copy(&tmp.addr, addr);
2723
2724         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2725                 peercnt_remove(peercnt);
2726                 ao2_ref(peercnt, -1); /* decrement ref from find */
2727         }
2728         return 0;
2729 }
2730
2731 /*!
2732  * \internal
2733  * \brief Create callno_limit entry based on configuration
2734  */
2735 static void build_callno_limits(struct ast_variable *v)
2736 {
2737         struct addr_range *addr_range = NULL;
2738         struct addr_range tmp;
2739         struct ast_ha *ha;
2740         int limit;
2741         int error;
2742         int found;
2743
2744         for (; v; v = v->next) {
2745                 limit = -1;
2746                 error = 0;
2747                 found = 0;
2748                 ha = ast_append_ha("permit", v->name, NULL, &error);
2749
2750                 /* check for valid config information */
2751                 if (error) {
2752                         ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2753                         continue;
2754                 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2755                         ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2756                         ast_free_ha(ha);
2757                         continue;
2758                 }
2759
2760                 ast_copy_ha(ha, &tmp.ha);
2761                 /* find or create the addr_range */
2762                 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2763                         ao2_lock(addr_range);
2764                         found = 1;
2765                 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2766                         ast_free_ha(ha);
2767                         return; /* out of memory */
2768                 }
2769
2770                 /* copy over config data into addr_range object */
2771                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2772                 ast_free_ha(ha); /* cleanup the tmp ha */
2773                 addr_range->limit = limit;
2774                 addr_range->delme = 0;
2775
2776                 /* cleanup */
2777                 if (found) {
2778                         ao2_unlock(addr_range);
2779                 } else {
2780                         ao2_link(callno_limits, addr_range);
2781                 }
2782                 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2783         }
2784 }
2785
2786 /*!
2787  * \internal
2788  * \brief Create calltoken_ignores entry based on configuration
2789  */
2790 static int add_calltoken_ignore(const char *addr)
2791 {
2792         struct addr_range tmp;
2793         struct addr_range *addr_range = NULL;
2794         struct ast_ha *ha = NULL;
2795         int error = 0;
2796
2797         if (ast_strlen_zero(addr)) {
2798                 ast_log(LOG_WARNING, "invalid calltokenoptional %s\n", addr);
2799                 return -1;
2800         }
2801
2802         ha = ast_append_ha("permit", addr, NULL, &error);
2803
2804         /* check for valid config information */
2805         if (error) {
2806                 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2807                 return -1;
2808         }
2809
2810         ast_copy_ha(ha, &tmp.ha);
2811         /* find or create the addr_range */
2812         if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2813                 ao2_lock(addr_range);
2814                 addr_range->delme = 0;
2815                 ao2_unlock(addr_range);
2816         } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2817                 /* copy over config data into addr_range object */
2818                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2819                 ao2_link(calltoken_ignores, addr_range);
2820         } else {
2821                 ast_free_ha(ha);
2822                 return -1;
2823         }
2824
2825         ast_free_ha(ha);
2826         ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2827
2828         return 0;
2829 }
2830
2831 static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2832 {
2833         struct ao2_iterator i;
2834         struct peercnt *peercnt;
2835         struct ast_sockaddr addr;
2836         int found = 0;
2837
2838         switch (cmd) {
2839         case CLI_INIT:
2840                 e->command = "iax2 show callnumber usage";
2841                 e->usage =
2842                         "Usage: iax2 show callnumber usage [IP address]\n"
2843                         "       Shows current IP addresses which are consuming iax2 call numbers\n";
2844                 return NULL;
2845         case CLI_GENERATE:
2846                 return NULL;
2847         case CLI_HANDLER:
2848                 if (a->argc < 4 || a->argc > 5)
2849                         return CLI_SHOWUSAGE;
2850
2851                 if (a->argc == 4) {
2852                         ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2853                 }
2854
2855                 i = ao2_iterator_init(peercnts, 0);
2856                 while ((peercnt = ao2_iterator_next(&i))) {
2857                         ast_sockaddr_copy(&addr, &peercnt->addr);
2858
2859                         if (a->argc == 5) {
2860                                 if (!strcasecmp(a->argv[4], ast_sockaddr_stringify(&addr))) {
2861                                         ast_cli(a->fd, "%-45s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2862                                         ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2863                                         ao2_ref(peercnt, -1);
2864                                         found = 1;
2865                                         break;
2866                                 }
2867                         } else {
2868                                 ast_cli(a->fd, "%-45s %-12d %-12d\n", ast_sockaddr_stringify(&addr), peercnt->cur, peercnt->limit);
2869                         }
2870                         ao2_ref(peercnt, -1);
2871                 }
2872                 ao2_iterator_destroy(&i);
2873
2874                 if (a->argc == 4) {
2875                         size_t pool_avail = callno_pool.available;
2876                         size_t trunk_pool_avail = callno_pool_trunk.available;
2877
2878                         ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
2879                                          "Non-CallToken Validated Callno Used:   %d\n",
2880                                 global_maxcallno_nonval,
2881                                 total_nonval_callno_used);
2882
2883                         ast_cli(a->fd,   "Total Available Callno:                %zu\n"
2884                                          "Regular Callno Available:              %zu\n"
2885                                          "Trunk Callno Available:                %zu\n",
2886                                 pool_avail + trunk_pool_avail,
2887                                 pool_avail,
2888                                 trunk_pool_avail);
2889                 } else if (a->argc == 5 && !found) {
2890                         ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
2891                 }
2892
2893
2894                 return CLI_SUCCESS;
2895         default:
2896                 return NULL;
2897         }
2898 }
2899
2900 static int get_unused_callno(enum callno_type type, int validated, callno_entry *entry)
2901 {
2902         struct call_number_pool *pool = NULL;
2903         callno_entry swap;
2904         size_t choice;
2905
2906         switch (type) {
2907         case CALLNO_TYPE_NORMAL:
2908                 pool = &callno_pool;
2909                 break;
2910         case CALLNO_TYPE_TRUNK:
2911                 pool = &callno_pool_trunk;
2912                 break;
2913         default:
2914                 ast_assert(0);
2915                 break;
2916         }
2917
2918         /* If we fail, make sure this has a defined value */
2919         *entry = 0;
2920
2921         /* We lock here primarily to ensure thread safety of the
2922          * total_nonval_callno_used check and increment */
2923         ast_mutex_lock(&callno_pool_lock);
2924
2925         /* Bail out if we don't have any available call numbers */
2926         if (!pool->available) {
2927                 ast_log(LOG_WARNING, "Out of call numbers\n");
2928                 ast_mutex_unlock(&callno_pool_lock);
2929                 return 1;
2930         }
2931
2932         /* Only a certain number of non-validated call numbers should be allocated.
2933          * If there ever is an attack, this separates the calltoken validating users
2934          * from the non-calltoken validating users. */
2935         if (!validated && total_nonval_callno_used >= global_maxcallno_nonval) {
2936                 ast_log(LOG_WARNING,
2937                         "NON-CallToken callnumber limit is reached. Current: %d Max: %d\n",
2938                         total_nonval_callno_used,
2939                         global_maxcallno_nonval);
2940                 ast_mutex_unlock(&callno_pool_lock);
2941                 return 1;
2942         }
2943
2944         /* We use a modified Fisher-Yates-Durstenfeld Shuffle to maintain a list of
2945          * available call numbers.  The array of call numbers begins as an ordered
2946          * list from 1 -> n, and we keep a running tally of how many remain unclaimed
2947          * - let's call that x.  When a call number is needed we pick a random index
2948          * into the array between 0 and x and use that as our call number.  In a
2949          * typical FYD shuffle, we would swap the value that we are extracting with
2950          * the number at x, but in our case we swap and don't touch the value at x
2951          * because it is effectively invisible.  We rely on the rest of the IAX2 core
2952          * to return the number to us at some point.  Finally, we decrement x by 1
2953          * which establishes our new unused range.
2954          *
2955          * When numbers are returned to the pool, we put them just past x and bump x
2956          * by 1 so that this number is now available for re-use. */
2957
2958         choice = ast_random() % pool->available;
2959
2960         *entry = pool->numbers[choice];
2961         swap = pool->numbers[pool->available - 1];
2962
2963         pool->numbers[choice] = swap;
2964         pool->available--;
2965
2966         if (validated) {
2967                 CALLNO_ENTRY_SET_VALIDATED(*entry);
2968         } else {
2969                 total_nonval_callno_used++;
2970         }
2971
2972         ast_mutex_unlock(&callno_pool_lock);
2973
2974         return 0;
2975 }
2976
2977 static int replace_callno(const void *obj)
2978 {
2979         callno_entry entry = PTR_TO_CALLNO_ENTRY(obj);
2980         struct call_number_pool *pool;
2981
2982         /* We lock here primarily to ensure thread safety of the
2983          * total_nonval_callno_used check and decrement */
2984         ast_mutex_lock(&callno_pool_lock);
2985
2986         if (!CALLNO_ENTRY_IS_VALIDATED(entry)) {
2987                 if (total_nonval_callno_used) {
2988                         total_nonval_callno_used--;
2989                 } else {
2990                         ast_log(LOG_ERROR,
2991                                 "Attempted to decrement total non calltoken validated "
2992                                 "callnumbers below zero.  Callno is: %d\n",
2993                                 CALLNO_ENTRY_GET_CALLNO(entry));
2994                 }
2995         }
2996
2997         if (CALLNO_ENTRY_GET_CALLNO(entry) < TRUNK_CALL_START) {
2998                 pool = &callno_pool;
2999         } else {
3000                 pool = &callno_pool_trunk;
3001         }
3002
3003         ast_assert(pool->capacity > pool->available);
3004
3005         /* This clears the validated flag */
3006         entry = CALLNO_ENTRY_GET_CALLNO(entry);
3007
3008         pool->numbers[pool->available] = entry;
3009         pool->available++;
3010
3011         ast_mutex_unlock(&callno_pool_lock);
3012
3013         return 0;
3014 }
3015
3016 static int create_callno_pools(void)
3017 {
3018         uint16_t i;
3019
3020         callno_pool.available = callno_pool_trunk.available = 0;
3021
3022         /* We start at 2.  0 and 1 are reserved. */
3023         for (i = 2; i < TRUNK_CALL_START; i++) {
3024                 callno_pool.numbers[callno_pool.available] = i;
3025                 callno_pool.available++;
3026         }
3027
3028         for (i = TRUNK_CALL_START; i < IAX_MAX_CALLS; i++) {
3029                 callno_pool_trunk.numbers[callno_pool_trunk.available] = i;
3030                 callno_pool_trunk.available++;
3031         }
3032
3033         callno_pool.capacity = callno_pool.available;
3034         callno_pool_trunk.capacity = callno_pool_trunk.available;
3035
3036         ast_assert(callno_pool.capacity && callno_pool_trunk.capacity);
3037
3038         return 0;
3039 }
3040
3041 /*!
3042  * \internal
3043  * \brief Schedules delayed removal of iax2_pvt call number data
3044  *
3045  * \note After MIN_REUSE_TIME has passed for a destroyed iax2_pvt, the callno is
3046  * available again, and the address from the previous connection must be decremented
3047  * from the peercnts table.  This function schedules these operations to take place.
3048  */
3049 static void sched_delay_remove(struct ast_sockaddr *addr, callno_entry entry)
3050 {
3051         int i;
3052         struct peercnt *peercnt;
3053         struct peercnt tmp;
3054
3055         ast_sockaddr_copy(&tmp.addr, addr);
3056
3057         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
3058                 /* refcount is incremented with ao2_find.  keep that ref for the scheduler */
3059                 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_sockaddr_stringify_addr(addr), MIN_REUSE_TIME);
3060                 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
3061                 if (i == -1) {
3062                         ao2_ref(peercnt, -1);
3063                 }
3064         }
3065
3066         iax2_sched_add(
3067                 sched,
3068                 MIN_REUSE_TIME * 1000,
3069                 replace_callno,
3070                 CALLNO_ENTRY_TO_PTR(entry));
3071 }
3072
3073 /*!
3074  * \internal
3075  * \brief returns whether or not a frame is capable of starting a new IAX2 dialog.
3076  *
3077  * \note For this implementation, inbound pokes should _NOT_ be capable of allocating
3078  * a new callno.
3079  */
3080 static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
3081 {
3082         if (frametype != AST_FRAME_IAX) {
3083                 return 0;
3084         }
3085         switch (subclass) {
3086         case IAX_COMMAND_NEW:
3087         case IAX_COMMAND_REGREQ:
3088         case IAX_COMMAND_FWDOWNL:
3089         case IAX_COMMAND_REGREL:
3090                 return 1;
3091         case IAX_COMMAND_POKE:
3092                 if (!inbound) {
3093                         return 1;
3094                 }
3095                 break;
3096         }
3097         return 0;
3098 }
3099
3100 /*
3101  * \note Calling this function while holding another pvt lock can cause a deadlock.
3102  */
3103 static int __find_callno(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int return_locked, int check_dcallno)
3104 {
3105         int res = 0;
3106         int x;
3107         /* this call is calltoken validated as long as it is either NEW_FORCE
3108          * or NEW_ALLOW_CALLTOKEN_VALIDATED */
3109         int validated = (new > NEW_ALLOW) ? 1 : 0;
3110         char host[80];
3111
3112         if (new <= NEW_ALLOW) {
3113                 if (callno) {
3114                         struct chan_iax2_pvt *pvt;
3115                         struct chan_iax2_pvt tmp_pvt = {
3116                                 .callno = dcallno,
3117                                 .peercallno = callno,
3118                                 .transfercallno = callno,
3119                                 /* hack!! */
3120                                 .frames_received = check_dcallno,
3121                         };
3122
3123                         ast_sockaddr_copy(&tmp_pvt.addr, addr);
3124                         /* this works for finding normal call numbers not involving transfering */
3125                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3126                                 if (return_locked) {
3127                                         ast_mutex_lock(&iaxsl[pvt->callno]);
3128                                 }
3129                                 res = pvt->callno;
3130                                 ao2_ref(pvt, -1);
3131                                 pvt = NULL;
3132                                 return res;
3133                         }
3134                         /* this searches for transfer call numbers that might not get caught otherwise */
3135                         memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
3136                         ast_sockaddr_copy(&tmp_pvt.transfer, addr);
3137                         if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
3138                                 if (return_locked) {
3139                                         ast_mutex_lock(&iaxsl[pvt->callno]);
3140                                 }
3141                                 res = pvt->callno;
3142                                 ao2_ref(pvt, -1);
3143                                 pvt = NULL;
3144                                 return res;
3145                         }
3146                 }
3147                         /* This will occur on the first response to a message that we initiated,
3148                  * such as a PING. */
3149                 if (dcallno) {
3150                         ast_mutex_lock(&iaxsl[dcallno]);
3151                 }
3152                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(addr, callno, dcallno, iaxs[dcallno], check_dcallno)) {
3153                         iaxs[dcallno]->peercallno = callno;
3154                         res = dcallno;
3155                         store_by_peercallno(iaxs[dcallno]);
3156                         if (!res || !return_locked) {
3157                                 ast_mutex_unlock(&iaxsl[dcallno]);
3158                         }
3159                         return res;
3160                 }
3161                 if (dcallno) {
3162                         ast_mutex_unlock(&iaxsl[dcallno]);
3163                 }
3164         }
3165         if (!res && (new >= NEW_ALLOW)) {
3166                 callno_entry entry;
3167
3168                 /* It may seem odd that we look through the peer list for a name for
3169                  * this *incoming* call.  Well, it is weird.  However, users don't
3170                  * have an IP address/port number that we can match against.  So,
3171                  * this is just checking for a peer that has that IP/port and
3172                  * assuming that we have a user of the same name.  This isn't always
3173                  * correct, but it will be changed if needed after authentication. */
3174                 if (!iax2_getpeername(*addr, host, sizeof(host)))
3175                         snprintf(host, sizeof(host), "%s", ast_sockaddr_stringify(addr));
3176
3177                 if (peercnt_add(addr)) {
3178                         /* This address has hit its callnumber limit.  When the limit
3179                          * is reached, the connection is not added to the peercnts table.*/
3180                         return 0;
3181                 }
3182
3183                 if (get_unused_callno(CALLNO_TYPE_NORMAL, validated, &entry)) {
3184                         /* since we ran out of space, remove the peercnt
3185                          * entry we added earlier */
3186                         peercnt_remove_by_addr(addr);
3187                         ast_log(LOG_WARNING, "No more space\n");
3188                         return 0;
3189                 }
3190                 x = CALLNO_ENTRY_GET_CALLNO(entry);
3191                 ast_mutex_lock(&iaxsl[x]);
3192
3193                 iaxs[x] = new_iax(addr, host);
3194                 if (iaxs[x]) {
3195                         if (iaxdebug)
3196                                 ast_debug(1, "Creating new call structure %d\n", x);
3197                         iaxs[x]->callno_entry = entry;
3198                         iaxs[x]->sockfd = sockfd;
3199                         ast_sockaddr_copy(&iaxs[x]->addr, addr);
3200                         iaxs[x]->peercallno = callno;
3201                         iaxs[x]->callno = x;
3202                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
3203                         iaxs[x]->expiry = min_reg_expire;
3204                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
3205                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
3206                         iaxs[x]->amaflags = amaflags;
3207                         ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
3208                         ast_string_field_set(iaxs[x], accountcode, accountcode);
3209                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
3210                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
3211                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
3212
3213                         if (iaxs[x]->peercallno) {
3214                                 store_by_peercallno(iaxs[x]);
3215                         }
3216                 } else {
3217                         ast_log(LOG_WARNING, "Out of resources\n");
3218                         ast_mutex_unlock(&iaxsl[x]);
3219                         replace_callno(CALLNO_ENTRY_TO_PTR(entry));
3220                         return 0;
3221                 }
3222                 if (!return_locked)
3223                         ast_mutex_unlock(&iaxsl[x]);
3224                 res = x;
3225         }
3226         return res;
3227 }
3228
3229 static int find_callno(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame) {
3230         return __find_callno(callno, dcallno, addr, new, sockfd, 0, full_frame);
3231 }
3232
3233 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct ast_sockaddr *addr, int new, int sockfd, int full_frame) {
3234
3235         return __find_callno(callno, dcallno, addr, new, sockfd, 1, full_frame);
3236 }
3237
3238 /*!
3239  * \brief Queue a frame to a call's owning asterisk channel
3240  *
3241  * \pre This function assumes that iaxsl[callno] is locked when called.
3242  *
3243  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3244  * was valid before calling it, it may no longer be valid after calling it.
3245  * This function may unlock and lock the mutex associated with this callno,
3246  * meaning that another thread may grab it and destroy the call.
3247  */
3248 static int iax2_queue_frame(int callno, struct ast_frame *f)
3249 {
3250         iax2_lock_owner(callno);
3251         if (iaxs[callno] && iaxs[callno]->owner) {
3252                 ast_queue_frame(iaxs[callno]->owner, f);
3253                 ast_channel_unlock(iaxs[callno]->owner);
3254         }
3255         return 0;
3256 }
3257
3258 /*!
3259  * \brief Queue a hold frame on the ast_channel owner
3260  *
3261  * This function queues a hold frame on the owner of the IAX2 pvt struct that
3262  * is active for the given call number.
3263  *
3264  * \pre Assumes lock for callno is already held.
3265  *
3266  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3267  * was valid before calling it, it may no longer be valid after calling it.
3268  * This function may unlock and lock the mutex associated with this callno,
3269  * meaning that another thread may grab it and destroy the call.
3270  */
3271 static int iax2_queue_hold(int callno, const char *musicclass)
3272 {
3273         iax2_lock_owner(callno);
3274         if (iaxs[callno] && iaxs[callno]->owner) {
3275                 ast_queue_hold(iaxs[callno]->owner, musicclass);
3276                 ast_channel_unlock(iaxs[callno]->owner);
3277         }
3278         return 0;
3279 }
3280
3281 /*!
3282  * \brief Queue an unhold frame on the ast_channel owner
3283  *
3284  * This function queues an unhold frame on the owner of the IAX2 pvt struct that
3285  * is active for the given call number.
3286  *
3287  * \pre Assumes lock for callno is already held.
3288  *
3289  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3290  * was valid before calling it, it may no longer be valid after calling it.
3291  * This function may unlock and lock the mutex associated with this callno,
3292  * meaning that another thread may grab it and destroy the call.
3293  */
3294 static int iax2_queue_unhold(int callno)
3295 {
3296         iax2_lock_owner(callno);
3297         if (iaxs[callno] && iaxs[callno]->owner) {
3298                 ast_queue_unhold(iaxs[callno]->owner);
3299                 ast_channel_unlock(iaxs[callno]->owner);
3300         }
3301         return 0;
3302 }
3303
3304 /*!
3305  * \brief Queue a hangup frame on the ast_channel owner
3306  *
3307  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
3308  * is active for the given call number.
3309  *
3310  * \pre Assumes lock for callno is already held.
3311  *
3312  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3313  * was valid before calling it, it may no longer be valid after calling it.
3314  * This function may unlock and lock the mutex associated with this callno,
3315  * meaning that another thread may grab it and destroy the call.
3316  */
3317 static int iax2_queue_hangup(int callno)
3318 {
3319         iax2_lock_owner(callno);
3320         if (iaxs[callno] && iaxs[callno]->owner) {
3321                 ast_queue_hangup(iaxs[callno]->owner);
3322                 ast_channel_unlock(iaxs[callno]->owner);
3323         }
3324         return 0;
3325 }
3326
3327 /*!
3328  * \note This function assumes that iaxsl[callno] is locked when called.
3329  *
3330  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3331  * was valid before calling it, it may no longer be valid after calling it.
3332  * This function calls iax2_queue_frame(), which may unlock and lock the mutex
3333  * associated with this callno, meaning that another thread may grab it and destroy the call.
3334  */
3335 static int __do_deliver(void *data)
3336 {
3337         /* Just deliver the packet by using queueing.  This is called by
3338           the IAX thread with the iaxsl lock held. */
3339         struct iax_frame *fr = data;
3340         fr->retrans = -1;
3341         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
3342         if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
3343                 iax2_queue_frame(fr->callno, &fr->af);
3344         /* Free our iax frame */
3345         iax2_frame_free(fr);
3346         /* And don't run again */
3347         return 0;
3348 }
3349
3350 static int handle_error(void)
3351 {
3352         /* XXX Ideally we should figure out why an error occurred and then abort those
3353            rather than continuing to try.  Unfortunately, the published interface does
3354            not seem to work XXX */
3355 #if 0
3356         struct sockaddr_in *sin;
3357         int res;
3358         struct msghdr m;
3359         struct sock_extended_err e;
3360         m.msg_name = NULL;
3361         m.msg_namelen = 0;
3362         m.msg_iov = NULL;
3363         m.msg_control = &e;
3364         m.msg_controllen = sizeof(e);
3365         m.msg_flags = 0;
3366         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
3367         if (res < 0)
3368                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
3369         else {
3370                 if (m.msg_controllen) {
3371                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
3372                         if (sin)
3373                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
3374                         else
3375                                 ast_log(LOG_WARNING, "No address detected??\n");
3376                 } else {
3377                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
3378                 }
3379         }
3380 #endif
3381         return 0;
3382 }
3383
3384 static int transmit_trunk(struct iax_frame *f, struct ast_sockaddr *addr, int sockfd)
3385 {
3386         int res;
3387         res = ast_sendto(sockfd, f->data, f->datalen, 0, addr);
3388
3389         if (res < 0) {
3390                 ast_debug(1, "Received error: %s\n", strerror(errno));
3391                 handle_error();
3392         } else
3393                 res = 0;
3394         return res;
3395 }
3396
3397 static int send_packet(struct iax_frame *f)
3398 {
3399         int res;
3400         int callno = f->callno;
3401
3402         /* Don't send if there was an error, but return error instead */
3403         if (!callno || !iaxs[callno] || iaxs[callno]->error)
3404             return -1;
3405
3406         /* Called with iaxsl held */
3407         if (iaxdebug) {
3408                 ast_debug(3, "Sending %u on %d/%d to %s\n", f->ts, callno, iaxs[callno]->peercallno, ast_sockaddr_stringify(&iaxs[callno]->addr));
3409         }
3410         if (f->transfer) {
3411                 iax_outputframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
3412                 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->transfer);
3413         } else {
3414                 iax_outputframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
3415                 res = ast_sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0, &iaxs[callno]->addr);
3416         }
3417         if (res < 0) {
3418                 if (iaxdebug)
3419                         ast_debug(1, "Received error: %s\n", strerror(errno));
3420                 handle_error();
3421         } else
3422                 res = 0;
3423
3424         return res;
3425 }
3426
3427 /*!
3428  * \note Since this function calls iax2_queue_hangup(), the pvt struct
3429  *       for the given call number may disappear during its execution.
3430  */
3431 static int iax2_predestroy(int callno)
3432 {
3433         struct ast_channel *c = NULL;
3434         struct chan_iax2_pvt *pvt = iaxs[callno];
3435
3436         if (!pvt)
3437                 return -1;
3438
3439         if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
3440                 iax2_destroy_helper(pvt);
3441                 ast_set_flag64(pvt, IAX_ALREADYGONE);
3442         }
3443
3444         if ((c = pvt->owner)) {
3445                 ast_channel_tech_pvt_set(c, NULL);
3446                 iax2_queue_hangup(callno);
3447                 pvt->owner = NULL;
3448                 ast_module_unref(ast_module_info->self);
3449         }
3450
3451         return 0;
3452 }
3453
3454 static void iax2_destroy(int callno)
3455 {
3456         struct chan_iax2_pvt *pvt = NULL;
3457         struct ast_channel *owner = NULL;
3458
3459 retry:
3460         if ((pvt = iaxs[callno])) {
3461 #if 0
3462                 /* iax2_destroy_helper gets called from this function later on.  When
3463                  * called twice, we get the (previously) familiar FRACK! errors in
3464                  * devmode, from the scheduler.  An alternative to this approach is to
3465                  * reset the scheduler entries to -1 when they're deleted in
3466                  * iax2_destroy_helper().  That approach was previously decided to be
3467                  * "wrong" because "the memory is going to be deallocated anyway.  Why
3468                  * should we be resetting those values?" */
3469                 iax2_destroy_helper(pvt);
3470 #endif
3471         }
3472
3473         owner = pvt ? pvt->owner : NULL;
3474
3475         if (owner) {
3476                 if (ast_channel_trylock(owner)) {
3477                         ast_debug(3, "Avoiding IAX destroy deadlock\n");
3478                         DEADLOCK_AVOIDANCE(&iaxsl[callno]);
3479                         goto retry;
3480                 }
3481         }
3482
3483         if (!owner) {
3484                 iaxs[callno] = NULL;
3485         }
3486
3487         if (pvt) {
3488                 if (!owner) {
3489                         pvt->owner = NULL;
3490                 } else {
3491                         /* If there's an owner, prod it to give up */
3492                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
3493                          * because we already hold the owner channel lock. */
3494                         ast_queue_hangup(owner);
3495                 }
3496
3497                 if (pvt->peercallno) {
3498                         remove_by_peercallno(pvt);
3499                 }
3500
3501                 if (pvt->transfercallno) {
3502                         remove_by_transfercallno(pvt);
3503                 }
3504
3505                 if (!owner) {
3506                         ao2_ref(pvt, -1);
3507                         pvt = NULL;
3508                 }
3509         }
3510
3511         if (owner) {
3512                 ast_channel_unlock(owner);
3513         }
3514 }
3515
3516 static int update_packet(struct iax_frame *f)
3517 {
3518         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
3519         struct ast_iax2_full_hdr *fh = f->data;
3520         struct ast_frame af;
3521
3522         /* if frame is encrypted. decrypt before updating it. */
3523         if (f->encmethods) {
3524                 decode_frame(&f->mydcx, fh, &af, &f->datalen);
3525         }
3526         /* Mark this as a retransmission */
3527         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
3528         /* Update iseqno */
3529         f->iseqno = iaxs[f->callno]->iseqno;
3530         fh->iseqno = f->iseqno;
3531
3532         /* Now re-encrypt the frame */
3533         if (f->encmethods) {
3534         /* since this is a retransmit frame, create a new random padding
3535          * before re-encrypting. */
3536                 build_rand_pad(f->semirand, sizeof(f->semirand));
3537                 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
3538         }
3539         return 0;
3540 }
3541
3542 static int attempt_transmit(const void *data);
3543 static void __attempt_transmit(const void *data)
3544 {
3545         /* Attempt to transmit the frame to the remote peer...
3546            Called without iaxsl held. */
3547         struct iax_frame *f = (struct iax_frame *)data;
3548         int freeme = 0;
3549         int callno = f->callno;
3550
3551         /* Make sure this call is still active */
3552         if (callno)
3553                 ast_mutex_lock(&iaxsl[callno]);
3554         if (callno && iaxs[callno]) {
3555                 if (f->retries < 0) {
3556                         /* Already ACK'd */
3557                         freeme = 1;
3558                 } else if (f->retries >= max_retries) {
3559                         /* Too many attempts.  Record an error. */
3560                         if (f->transfer) {
3561                                 /* Transfer timeout */
3562                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
3563                         } else if (f->final) {
3564                                 iax2_destroy(callno);
3565                         } else {
3566                                 if (iaxs[callno]->owner) {
3567                                         ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %u, subclass = %d, ts=%u, seqno=%d)\n",
3568                                                 ast_sockaddr_stringify_addr(&iaxs[f->callno]->addr),
3569                                                 ast_channel_name(iaxs[f->callno]->owner),
3570                                                 f->af.frametype,
3571                                                 f->af.subclass.integer,
3572                                                 f->ts,
3573                                                 f->oseqno);
3574                                 }
3575                                 iaxs[callno]->error = ETIMEDOUT;
3576                                 if (iaxs[callno]->owner) {
3577                                         struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
3578                                         /* Hangup the fd */
3579                                         iax2_queue_frame(callno, &fr); /* XXX */
3580                                         /* Remember, owner could disappear */
3581                                         if (iaxs[callno] && iaxs[callno]->owner)
3582                                                 ast_channel_hangupcause_set(iaxs[callno]->owner, AST_CAUSE_DESTINATION_OUT_OF_ORDER);
3583                                 } else {
3584                                         if (iaxs[callno]->reg) {
3585                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
3586                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
3587                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
3588                                         }
3589                                         iax2_destroy(callno);
3590                                 }
3591                         }
3592                         freeme = 1;
3593                 } else {
3594                         /* Update it if it needs it */
3595                         update_packet(f);
3596                         /* Attempt transmission */
3597                         send_packet(f);
3598                         f->retries++;
3599                         /* Try again later after 10 times as long */
3600                         f->retrytime *= 10;
3601                         if (f->retrytime > MAX_RETRY_TIME)
3602                                 f->retrytime = MAX_RETRY_TIME;
3603                         /* Transfer messages max out at one second */
3604                         if (f->transfer && (f->retrytime > 1000))
3605                                 f->retrytime = 1000;
3606                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
3607                 }
3608         } else {
3609                 /* Make sure it gets freed */
3610                 f->retries = -1;
3611                 freeme = 1;
3612         }
3613
3614         if (freeme) {
3615                 /* Don't attempt delivery, just remove it from the queue */
3616                 AST_LIST_REMOVE(&frame_queue[callno], f, list);
3617                 ast_mutex_unlock(&iaxsl[callno]);
3618                 f->retrans = -1; /* this is safe because this is the scheduled function */
3619                 /* Free the IAX frame */
3620                 iax2_frame_free(f);
3621         } else if (callno) {
3622                 ast_mutex_unlock(&iaxsl[callno]);
3623         }
3624 }
3625
3626 static int attempt_transmit(const void *data)
3627 {
3628 #ifdef SCHED_MULTITHREADED
3629         if (schedule_action(__attempt_transmit, data))
3630 #endif
3631                 __attempt_transmit(data);
3632         return 0;
3633 }
3634
3635 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3636 {
3637         struct iax2_peer *peer = NULL;
3638         struct iax2_user *user = NULL;
3639         static const char * const choices[] = { "all", NULL };
3640         char *cmplt;
3641
3642         switch (cmd) {
3643         case CLI_INIT:
3644                 e->command = "iax2 prune realtime";
3645                 e->usage =
3646                         "Usage: iax2 prune realtime [<peername>|all]\n"
3647                         "       Prunes object(s) from the cache\n";
3648                 return NULL;
3649         case CLI_GENERATE:
3650                 if (a->pos == 3) {
3651                         cmplt = ast_cli_complete(a->word, choices, a->n);
3652                         if (!cmplt)
3653                                 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
3654                         return cmplt;
3655                 }
3656                 return NULL;
3657         }
3658         if (a->argc != 4)
3659                 return CLI_SHOWUSAGE;
3660         if (!strcmp(a->argv[3], "all")) {
3661                 prune_users();
3662                 prune_peers();
3663                 ast_cli(a->fd, "Cache flushed successfully.\n");
3664                 return CLI_SUCCESS;
3665         }
3666         peer = find_peer(a->argv[3], 0);
3667         user = find_user(a->argv[3]);
3668         if (peer || user) {
3669                 if (peer) {
3670                         if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
3671                                 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
3672                                 expire_registry(peer_ref(peer));
3673                                 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
3674                         } else {
3675                                 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
3676                         }
3677                         peer_unref(peer);
3678                 }
3679                 if (user) {
3680                         if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
3681                                 ast_set_flag64(user, IAX_RTAUTOCLEAR);
3682                                 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
3683                         } else {
3684                                 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
3685                         }
3686                         ao2_unlink(users,user);
3687                         user_unref(user);
3688                 }
3689         } else {
3690                 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
3691         }
3692
3693         return CLI_SUCCESS;
3694 }
3695
3696 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3697 {
3698         switch (cmd) {
3699         case CLI_INIT:
3700                 e->command = "iax2 test losspct";
3701                 e->usage =
3702                         "Usage: iax2 test losspct <percentage>\n"
3703                         "       For testing, throws away <percentage> percent of incoming packets\n";
3704                 return NULL;
3705         case CLI_GENERATE:
3706                 return NULL;
3707         }
3708         if (a->argc != 4)
3709                 return CLI_SHOWUSAGE;
3710
3711         test_losspct = atoi(a->argv[3]);
3712
3713         return CLI_SUCCESS;
3714 }
3715
3716 #ifdef IAXTESTS
3717 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3718 {
3719         switch (cmd) {
3720         case CLI_INIT:
3721                 e->command = "iax2 test late";
3722                 e->usage =
3723                         "Usage: iax2 test late <ms>\n"
3724                         "       For testing, count the next frame as <ms> ms late\n";
3725                 return NULL;
3726         case CLI_GENERATE:
3727                 return NULL;
3728         }
3729
3730         if (a->argc != 4)
3731                 return CLI_SHOWUSAGE;
3732
3733         test_late = atoi(a->argv[3]);
3734
3735         return CLI_SUCCESS;
3736 }
3737
3738 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3739 {
3740         switch (cmd) {
3741         case CLI_INIT:
3742                 e->command = "iax2 test resync";
3743                 e->usage =
3744                         "Usage: iax2 test resync <ms>\n"
3745                         "       For testing, adjust all future frames by <ms> ms\n";
3746                 return NULL;
3747         case CLI_GENERATE:
3748                 return NULL;
3749         }
3750
3751         if (a->argc != 4)
3752                 return CLI_SHOWUSAGE;
3753
3754         test_resync = atoi(a->argv[3]);
3755
3756         return CLI_SUCCESS;
3757 }
3758
3759 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3760 {
3761         switch (cmd) {
3762         case CLI_INIT:
3763                 e->command = "iax2 test jitter";
3764                 e->usage =
3765                         "Usage: iax2 test jitter <ms> <pct>\n"
3766                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
3767                         "       percentage of packets. If <pct> is not specified, adds\n"
3768                         "       jitter to all packets.\n";
3769                 return NULL;
3770         case CLI_GENERATE:
3771                 return NULL;
3772         }
3773
3774         if (a->argc < 4 || a->argc > 5)
3775                 return CLI_SHOWUSAGE;
3776
3777         test_jit = atoi(a->argv[3]);
3778         if (a->argc == 5)
3779                 test_jitpct = atoi(a->argv[4]);
3780
3781         return CLI_SUCCESS;
3782 }
3783 #endif /* IAXTESTS */
3784
3785 /*!