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