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