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