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