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