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