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