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