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