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