24f49d8bf44fe3345cd2e4f39d0554e8f21d05d3
[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 *new;
1922
1923         if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
1924                 return 1; /* do not queue this frame */
1925         } else if (!(new = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
1926                 return -1;  /* out of memory */
1927         }
1928
1929         memcpy(&new->f, f, sizeof(new->f)); /* copy ast_frame into our queue entry */
1930
1931         if (new->f.datalen) { /* if there is data in this frame copy it over as well */
1932                 if (!(new->f.data.ptr = ast_calloc(1, new->f.datalen))) {
1933                         free_signaling_queue_entry(new);
1934                         return -1;
1935                 }
1936                 memcpy(new->f.data.ptr, f->data.ptr, sizeof(*new->f.data.ptr));
1937         }
1938         AST_LIST_INSERT_TAIL(&pvt->signaling_queue, new, next);
1939
1940         return 0;
1941 }
1942
1943 static void pvt_destructor(void *obj)
1944 {
1945         struct chan_iax2_pvt *pvt = obj;
1946         struct iax_frame *cur = NULL;
1947         struct signaling_queue_entry *s = NULL;
1948
1949         ast_mutex_lock(&iaxsl[pvt->callno]);
1950
1951         iax2_destroy_helper(pvt);
1952
1953         sched_delay_remove(&pvt->addr, pvt->callno_entry);
1954         pvt->callno_entry = NULL;
1955
1956         /* Already gone */
1957         ast_set_flag64(pvt, IAX_ALREADYGONE);
1958
1959         AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
1960                 /* Cancel any pending transmissions */
1961                 cur->retries = -1;
1962         }
1963
1964         ast_mutex_unlock(&iaxsl[pvt->callno]);
1965
1966         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
1967                 free_signaling_queue_entry(s);
1968         }
1969
1970         if (pvt->reg) {
1971                 pvt->reg->callno = 0;
1972         }
1973
1974         if (!pvt->owner) {
1975                 jb_frame frame;
1976                 if (pvt->vars) {
1977                     ast_variables_destroy(pvt->vars);
1978                     pvt->vars = NULL;
1979                 }
1980
1981                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
1982                         iax2_frame_free(frame.data);
1983                 }
1984
1985                 jb_destroy(pvt->jb);
1986                 ast_string_field_free_memory(pvt);
1987         }
1988 }
1989
1990 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1991 {
1992         struct chan_iax2_pvt *tmp;
1993         jb_conf jbconf;
1994
1995         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
1996                 return NULL;
1997         }
1998
1999         if (ast_string_field_init(tmp, 32)) {
2000                 ao2_ref(tmp, -1);
2001                 tmp = NULL;
2002                 return NULL;
2003         }
2004                 
2005         tmp->prefs = prefs;
2006         tmp->pingid = -1;
2007         tmp->lagid = -1;
2008         tmp->autoid = -1;
2009         tmp->authid = -1;
2010         tmp->initid = -1;
2011         tmp->keyrotateid = -1;
2012
2013         ast_string_field_set(tmp,exten, "s");
2014         ast_string_field_set(tmp,host, host);
2015
2016         tmp->jb = jb_new();
2017         tmp->jbid = -1;
2018         jbconf.max_jitterbuf = maxjitterbuffer;
2019         jbconf.resync_threshold = resyncthreshold;
2020         jbconf.max_contig_interp = maxjitterinterps;
2021         jbconf.target_extra = jittertargetextra;
2022         jb_setconf(tmp->jb,&jbconf);
2023
2024         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
2025
2026         tmp->hold_signaling = 1;
2027         AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
2028
2029         return tmp;
2030 }
2031
2032 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
2033 {
2034         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
2035         if (new) {
2036                 size_t afdatalen = new->afdatalen;
2037                 memcpy(new, fr, sizeof(*new));
2038                 iax_frame_wrap(new, &fr->af);
2039                 new->afdatalen = afdatalen;
2040                 new->data = NULL;
2041                 new->datalen = 0;
2042                 new->direction = DIRECTION_INGRESS;
2043                 new->retrans = -1;
2044         }
2045         return new;
2046 }
2047 /* keep these defined in this order.  They are used in find_callno to
2048  * determine whether or not a new call number should be allowed. */
2049 enum {
2050         /* do not allow a new call number, only search ones in use for match */
2051         NEW_PREVENT = 0,
2052         /* search for match first, then allow a new one to be allocated */
2053         NEW_ALLOW = 1,
2054         /* do not search for match, force a new call number */
2055         NEW_FORCE = 2,
2056         /* do not search for match, force a new call number.  Signifies call number
2057          * has been calltoken validated */
2058         NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
2059 };
2060
2061 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
2062 {
2063         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2064                 (cur->addr.sin_port == sin->sin_port)) {
2065                 /* This is the main host */
2066                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
2067                          (check_dcallno ? dcallno == cur->callno : 1) ) {
2068                         /* That's us.  Be sure we keep track of the peer call number */
2069                         return 1;
2070                 }
2071         }
2072         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2073             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
2074                 /* We're transferring */
2075                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
2076                         return 1;
2077         }
2078         return 0;
2079 }
2080
2081 static int make_trunk(unsigned short callno, int locked)
2082 {
2083         int x;
2084         int res= 0;
2085         struct callno_entry *callno_entry;
2086         if (iaxs[callno]->oseqno) {
2087                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
2088                 return -1;
2089         }
2090         if (callno & TRUNK_CALL_START) {
2091                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
2092                 return -1;
2093         }
2094
2095         if (!(callno_entry = get_unused_callno(1, iaxs[callno]->callno_entry->validated))) {
2096                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
2097                 return -1;
2098         }
2099
2100         x = callno_entry->callno;
2101         ast_mutex_lock(&iaxsl[x]);
2102
2103         /*!
2104          * \note We delete these before switching the slot, because if
2105          * they fire in the meantime, they will generate a warning.
2106          */
2107         AST_SCHED_DEL(sched, iaxs[callno]->pingid);
2108         AST_SCHED_DEL(sched, iaxs[callno]->lagid);
2109         iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
2110         iaxs[x] = iaxs[callno];
2111         iaxs[x]->callno = x;
2112
2113         /* since we copied over the pvt from a different callno, make sure the old entry is replaced
2114          * before assigning the new one */
2115         if (iaxs[x]->callno_entry) {
2116                 iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, iaxs[x]->callno_entry);
2117         }
2118         iaxs[x]->callno_entry = callno_entry;
2119
2120         iaxs[callno] = NULL;
2121         /* Update the two timers that should have been started */
2122         iaxs[x]->pingid = iax2_sched_add(sched, 
2123                 ping_time * 1000, send_ping, (void *)(long)x);
2124         iaxs[x]->lagid = iax2_sched_add(sched, 
2125                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
2126
2127         if (locked)
2128                 ast_mutex_unlock(&iaxsl[callno]);
2129         res = x;
2130         if (!locked)
2131                 ast_mutex_unlock(&iaxsl[x]);
2132
2133         /* We moved this call from a non-trunked to a trunked call */
2134         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
2135
2136         return res;
2137 }
2138
2139 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
2140 {
2141         if (!pvt->transfercallno) {
2142                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2143                 return;
2144         }
2145
2146         ao2_link(iax_transfercallno_pvts, pvt);
2147 }
2148
2149 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
2150 {
2151         if (!pvt->transfercallno) {
2152                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2153                 return;
2154         }
2155
2156         ao2_unlink(iax_transfercallno_pvts, pvt);
2157 }
2158 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
2159 {
2160         if (!pvt->peercallno) {
2161                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2162                 return;
2163         }
2164
2165         ao2_link(iax_peercallno_pvts, pvt);
2166 }
2167
2168 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
2169 {
2170         if (!pvt->peercallno) {
2171                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2172                 return;
2173         }
2174
2175         ao2_unlink(iax_peercallno_pvts, pvt);
2176 }
2177
2178 static int addr_range_delme_cb(void *obj, void *arg, int flags)
2179 {
2180         struct addr_range *lim = obj;
2181         lim->delme = 1;
2182         return 0;
2183 }
2184
2185 static int addr_range_hash_cb(const void *obj, const int flags)
2186 {
2187         const struct addr_range *lim = obj;
2188         struct sockaddr_in sin;
2189         ast_sockaddr_to_sin(&lim->ha.addr, &sin);
2190         return abs((int) sin.sin_addr.s_addr);
2191 }
2192
2193 static int addr_range_cmp_cb(void *obj, void *arg, int flags)
2194 {
2195         struct addr_range *lim1 = obj, *lim2 = arg;
2196         return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
2197                         !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
2198                         CMP_MATCH | CMP_STOP : 0;
2199 }
2200
2201 static int peercnt_hash_cb(const void *obj, const int flags)
2202 {
2203         const struct peercnt *peercnt = obj;
2204         return abs((int) peercnt->addr);
2205 }
2206
2207 static int peercnt_cmp_cb(void *obj, void *arg, int flags)
2208 {
2209         struct peercnt *peercnt1 = obj, *peercnt2 = arg;
2210         return (peercnt1->addr == peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
2211 }
2212
2213 static int addr_range_match_address_cb(void *obj, void *arg, int flags)
2214 {
2215         struct addr_range *addr_range = obj;
2216         struct sockaddr_in *sin = arg;
2217         struct sockaddr_in ha_netmask_sin;
2218         struct sockaddr_in ha_addr_sin;
2219
2220         ast_sockaddr_to_sin(&addr_range->ha.netmask, &ha_netmask_sin);
2221         ast_sockaddr_to_sin(&addr_range->ha.addr, &ha_addr_sin);
2222
2223         if ((sin->sin_addr.s_addr & ha_netmask_sin.sin_addr.s_addr) == ha_addr_sin.sin_addr.s_addr) {
2224                 return CMP_MATCH | CMP_STOP;
2225         }
2226         return 0;
2227 }
2228
2229 /*! 
2230  * \internal
2231  *
2232  * \brief compares sin to calltoken_ignores table to determine if validation is required.
2233  */
2234 static int calltoken_required(struct sockaddr_in *sin, const char *name, int subclass)
2235 {
2236         struct addr_range *addr_range;
2237         struct iax2_peer *peer = NULL;
2238         struct iax2_user *user = NULL;
2239         /* if no username is given, check for guest accounts */
2240         const char *find = S_OR(name, "guest");
2241         int res = 1;  /* required by default */
2242         int optional = 0;
2243         enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2244         /* There are only two cases in which calltoken validation is not required.
2245          * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2246          *         the peer definition has not set the requirecalltoken option.
2247          * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2248          */
2249
2250         /* ----- Case 1 ----- */
2251         if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, sin))) {
2252                 ao2_ref(addr_range, -1);
2253                 optional = 1;
2254         }
2255
2256         /* ----- Case 2 ----- */
2257         if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2258                 calltoken_required = user->calltoken_required;
2259         } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, sin))) {
2260                 calltoken_required = user->calltoken_required;
2261         } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2262                 calltoken_required = peer->calltoken_required;
2263         } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, sin))) {
2264                 calltoken_required = peer->calltoken_required;
2265         }
2266
2267         if (peer) {
2268                 peer_unref(peer);
2269         }
2270         if (user) {
2271                 user_unref(user);
2272         }
2273
2274         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);
2275         if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2276                 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2277                 res = 0;
2278         }
2279
2280         return res;
2281 }
2282
2283 /*! 
2284  * \internal
2285  *
2286  * \brief set peercnt callno limit.
2287  *
2288  * \details 
2289  * First looks in custom definitions. If not found, global limit
2290  * is used.  Entries marked as reg already have
2291  * a custom limit set by a registration and are not modified.
2292  */
2293 static void set_peercnt_limit(struct peercnt *peercnt)
2294 {
2295         uint16_t limit = global_maxcallno;
2296         struct addr_range *addr_range;
2297         struct sockaddr_in sin = {
2298                 .sin_addr.s_addr = peercnt->addr,
2299         };
2300
2301
2302         if (peercnt->reg && peercnt->limit) {
2303                 return; /* this peercnt has a custom limit set by a registration */
2304         }
2305
2306         if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &sin))) {
2307                 limit = addr_range->limit;
2308                 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_inet_ntoa(sin.sin_addr));
2309                 ao2_ref(addr_range, -1);
2310         }
2311
2312         peercnt->limit = limit;
2313 }
2314
2315 /*! 
2316  * \internal
2317  * \brief sets limits for all peercnts in table. done on reload to reflect changes in conf.
2318  */
2319 static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
2320 {
2321         struct peercnt *peercnt = obj;
2322
2323         set_peercnt_limit(peercnt);
2324         ast_debug(1, "Reset limits for peercnts table\n");
2325
2326         return 0;
2327 }
2328
2329 /*! 
2330  * \internal
2331  * \brief returns match if delme is set. 
2332  */
2333 static int prune_addr_range_cb(void *obj, void *arg, int flags)
2334 {
2335         struct addr_range *addr_range = obj;
2336
2337         return addr_range->delme ? CMP_MATCH : 0;
2338 }
2339
2340 /*! 
2341  * \internal
2342  * \brief modifies peercnt entry in peercnts table. Used to set custom limit or mark a registered ip
2343  */
2344 static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
2345 {
2346         /* this function turns off and on custom callno limits set by peer registration */
2347         struct peercnt *peercnt;
2348         struct peercnt tmp = {
2349                 .addr = 0,
2350         };
2351         struct sockaddr_in sin;
2352
2353         ast_sockaddr_to_sin(sockaddr, &sin);
2354
2355         tmp.addr = sin.sin_addr.s_addr;
2356
2357         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2358                 peercnt->reg = reg;
2359                 if (limit) {
2360                         peercnt->limit = limit;
2361                 } else {
2362                         set_peercnt_limit(peercnt);
2363                 }
2364                 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_inet_ntoa(sin.sin_addr), peercnt->limit, peercnt->reg);
2365                 ao2_ref(peercnt, -1); /* decrement ref from find */
2366         }
2367 }
2368
2369 /*! 
2370  * \internal
2371  * \brief adds an ip to the peercnts table, increments connection count if it already exists
2372  *
2373  * \details First searches for the address in the peercnts table.  If found
2374  * the current count is incremented.  If not found a new peercnt is allocated
2375  * and linked into the peercnts table with a call number count of 1.
2376  */
2377 static int peercnt_add(struct sockaddr_in *sin)
2378 {
2379         struct peercnt *peercnt;
2380         unsigned long addr = sin->sin_addr.s_addr;
2381         int res = 0;
2382         struct peercnt tmp = {
2383                 .addr = addr,
2384         };
2385
2386         /* Reasoning for peercnts container lock:  Two identical ip addresses
2387          * could be added by different threads at the "same time". Without the container
2388          * lock, both threads could alloc space for the same object and attempt
2389          * to link to table.  With the lock, one would create the object and link
2390          * to table while the other would find the already created peercnt object
2391          * rather than creating a new one. */
2392         ao2_lock(peercnts);
2393         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2394                 ao2_lock(peercnt);
2395         } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2396                 ao2_lock(peercnt);
2397                 /* create and set defaults */
2398                 peercnt->addr = addr;
2399                 set_peercnt_limit(peercnt);
2400                 /* guarantees it does not go away after unlocking table
2401                  * ao2_find automatically adds this */
2402                 ao2_link(peercnts, peercnt);
2403         } else {
2404                 ao2_unlock(peercnts);
2405                 return -1;
2406         }
2407
2408         /* check to see if the address has hit its callno limit.  If not increment cur. */
2409         if (peercnt->limit > peercnt->cur) {
2410                 peercnt->cur++;
2411                 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin->sin_addr));
2412         } else { /* max num call numbers for this peer has been reached! */
2413                 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_inet_ntoa(sin->sin_addr));
2414                 res = -1;
2415         }
2416
2417         /* clean up locks and ref count */
2418         ao2_unlock(peercnt);
2419         ao2_unlock(peercnts);
2420         ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2421
2422         return res;
2423 }
2424
2425 /*! 
2426  * \internal
2427  * \brief decrements a peercnts table entry
2428  */
2429 static void peercnt_remove(struct peercnt *peercnt)
2430 {
2431         struct sockaddr_in sin = {
2432                 .sin_addr.s_addr = peercnt->addr,
2433         };
2434
2435         if (peercnt) {
2436                 /* Container locked here since peercnt may be unlinked from list.  If left unlocked,
2437                  * peercnt_add could try and grab this entry from the table and modify it at the
2438                  * "same time" this thread attemps to unlink it.*/
2439                 ao2_lock(peercnts);
2440                 peercnt->cur--;
2441                 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin.sin_addr));
2442                 /* if this was the last connection from the peer remove it from table */
2443                 if (peercnt->cur == 0) {
2444                         ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2445                 }
2446                 ao2_unlock(peercnts);
2447         }
2448 }
2449
2450 /*! 
2451  * \internal
2452  * \brief called by scheduler to decrement object
2453  */
2454 static int peercnt_remove_cb(const void *obj)
2455 {
2456         struct peercnt *peercnt = (struct peercnt *) obj;
2457
2458         peercnt_remove(peercnt);
2459         ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2460
2461         return 0;
2462 }
2463
2464 /*! 
2465  * \internal
2466  * \brief decrements peercnts connection count, finds by addr
2467  */
2468 static int peercnt_remove_by_addr(struct sockaddr_in *sin)
2469 {
2470         struct peercnt *peercnt;
2471         struct peercnt tmp = {
2472                 .addr = sin->sin_addr.s_addr,
2473         };
2474
2475         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2476                 peercnt_remove(peercnt);
2477                 ao2_ref(peercnt, -1); /* decrement ref from find */
2478         }
2479         return 0;
2480 }
2481
2482 /*! 
2483  * \internal
2484  * \brief Create callno_limit entry based on configuration
2485  */
2486 static void build_callno_limits(struct ast_variable *v)
2487 {
2488         struct addr_range *addr_range = NULL;
2489         struct addr_range tmp;
2490         struct ast_ha *ha;
2491         int limit;
2492         int error;
2493         int found;
2494
2495         for (; v; v = v->next) {
2496                 limit = -1;
2497                 error = 0;
2498                 found = 0;
2499                 ha = ast_append_ha("permit", v->name, NULL, &error);
2500
2501                 /* check for valid config information */
2502                 if (error) {
2503                         ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2504                         continue;
2505                 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2506                         ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2507                         ast_free_ha(ha);
2508                         continue;
2509                 }
2510
2511                 ast_copy_ha(ha, &tmp.ha);
2512                 /* find or create the addr_range */
2513                 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2514                         ao2_lock(addr_range);
2515                         found = 1;
2516                 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2517                         ast_free_ha(ha);
2518                         return; /* out of memory */
2519                 }
2520
2521                 /* copy over config data into addr_range object */
2522                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2523                 ast_free_ha(ha); /* cleanup the tmp ha */
2524                 addr_range->limit = limit;
2525                 addr_range->delme = 0;
2526
2527                 /* cleanup */
2528                 if (found) {
2529                         ao2_unlock(addr_range);
2530                 } else {
2531                         ao2_link(callno_limits, addr_range);
2532                 }
2533                 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2534         }
2535 }
2536
2537 /*! 
2538  * \internal
2539  * \brief Create calltoken_ignores entry based on configuration
2540  */
2541 static int add_calltoken_ignore(const char *addr)
2542 {
2543         struct addr_range tmp;
2544         struct addr_range *addr_range = NULL;
2545         struct ast_ha *ha = NULL;
2546         int error = 0;
2547
2548         if (ast_strlen_zero(addr)) {
2549                 ast_log(LOG_WARNING, "invalid calltokenoptional %s\n", addr);
2550                 return -1;
2551         }
2552
2553         ha = ast_append_ha("permit", addr, NULL, &error);
2554
2555         /* check for valid config information */
2556         if (error) {
2557                 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2558                 return -1;
2559         }
2560
2561         ast_copy_ha(ha, &tmp.ha);
2562         /* find or create the addr_range */
2563         if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2564                 ao2_lock(addr_range);
2565                 addr_range->delme = 0;
2566                 ao2_unlock(addr_range);
2567         } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2568                 /* copy over config data into addr_range object */
2569                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2570                 ao2_link(calltoken_ignores, addr_range);
2571         } else {
2572                 ast_free_ha(ha);
2573                 return -1;
2574         }
2575
2576         ast_free_ha(ha);
2577         ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2578
2579         return 0;
2580 }
2581
2582 static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2583 {
2584         struct ao2_iterator i;
2585         struct peercnt *peercnt;
2586         struct sockaddr_in sin;
2587         int found = 0;
2588
2589         switch (cmd) {
2590         case CLI_INIT:
2591                 e->command = "iax2 show callnumber usage";
2592                 e->usage =
2593                         "Usage: iax2 show callnumber usage [IP address]\n"
2594                         "       Shows current IP addresses which are consuming iax2 call numbers\n";
2595                 return NULL;
2596         case CLI_GENERATE:
2597                 return NULL;
2598         case CLI_HANDLER:
2599                 if (a->argc < 4 || a->argc > 5)
2600                         return CLI_SHOWUSAGE;
2601
2602                 if (a->argc == 4) {
2603                         ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2604                 }
2605
2606                 i = ao2_iterator_init(peercnts, 0);
2607                 while ((peercnt = ao2_iterator_next(&i))) {
2608                         sin.sin_addr.s_addr = peercnt->addr;
2609                         if (a->argc == 5) {
2610                                 if (!strcasecmp(a->argv[4], ast_inet_ntoa(sin.sin_addr))) {
2611                                         ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2612                                         ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2613                                         ao2_ref(peercnt, -1);
2614                                         found = 1;
2615                                         break;
2616                                 }
2617                         } else {
2618                                 ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2619                         }
2620                         ao2_ref(peercnt, -1);
2621                 }
2622                 ao2_iterator_destroy(&i);
2623
2624                 if (a->argc == 4) {
2625                         ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
2626                                          "Non-CallToken Validated Callno Used:   %d\n",
2627                                 global_maxcallno_nonval,
2628                                 total_nonval_callno_used);
2629
2630                         ast_cli(a->fd,   "Total Available Callno:                %d\n"
2631                                          "Regular Callno Available:              %d\n"
2632                                          "Trunk Callno Available:                %d\n",
2633                                 ao2_container_count(callno_pool) + ao2_container_count(callno_pool_trunk),
2634                                 ao2_container_count(callno_pool),
2635                                 ao2_container_count(callno_pool_trunk));
2636                 } else if (a->argc == 5 && !found) {
2637                         ast_cli(a->fd, "No call number table entries for %s found\n", a->argv[4] );
2638                 }
2639
2640
2641                 return CLI_SUCCESS;
2642         default:
2643                 return NULL;
2644         }
2645 }
2646
2647 static struct callno_entry *get_unused_callno(int trunk, int validated)
2648 {
2649         struct callno_entry *callno_entry = NULL;
2650         if ((!ao2_container_count(callno_pool) && !trunk) || (!ao2_container_count(callno_pool_trunk) && trunk)) {
2651                 ast_log(LOG_WARNING, "Out of CallNumbers\n");
2652                 /* Minor optimization for the extreme case. */
2653                 return NULL;
2654         }
2655
2656         /* the callno_pool container is locked here primarily to ensure thread
2657          * safety of the total_nonval_callno_used check and increment */
2658         ao2_lock(callno_pool);
2659
2660         /* only a certain number of nonvalidated call numbers should be allocated.
2661          * If there ever is an attack, this separates the calltoken validating
2662          * users from the non calltoken validating users. */
2663         if (!validated && (total_nonval_callno_used >= global_maxcallno_nonval)) {
2664                 ast_log(LOG_WARNING, "NON-CallToken callnumber limit is reached. Current:%d Max:%d\n", total_nonval_callno_used, global_maxcallno_nonval);
2665                 ao2_unlock(callno_pool);
2666                 return NULL;
2667         }
2668
2669         /* unlink the object from the container, taking over ownership
2670          * of the reference the container had to the object */
2671         callno_entry = ao2_find((trunk ? callno_pool_trunk : callno_pool), NULL, OBJ_POINTER | OBJ_UNLINK | OBJ_CONTINUE);
2672
2673         if (callno_entry) {
2674                 callno_entry->validated = validated;
2675                 if (!validated) {
2676                         total_nonval_callno_used++;
2677                 }
2678         }
2679
2680         ao2_unlock(callno_pool);
2681         return callno_entry;
2682 }
2683
2684 static int replace_callno(const void *obj)
2685 {
2686         struct callno_entry *callno_entry = (struct callno_entry *) obj;
2687
2688         /* the callno_pool container is locked here primarily to ensure thread
2689          * safety of the total_nonval_callno_used check and decrement */
2690         ao2_lock(callno_pool);
2691
2692         if (!callno_entry->validated && (total_nonval_callno_used != 0)) {
2693                 total_nonval_callno_used--;
2694         } else if (!callno_entry->validated && (total_nonval_callno_used == 0)) {
2695                 ast_log(LOG_ERROR, "Attempted to decrement total non calltoken validated callnumbers below zero... Callno is:%d \n", callno_entry->callno);
2696         }
2697
2698         if (callno_entry->callno < TRUNK_CALL_START) {
2699                 ao2_link(callno_pool, callno_entry);
2700         } else {
2701                 ao2_link(callno_pool_trunk, callno_entry);
2702         }
2703         ao2_ref(callno_entry, -1); /* only container ref remains */
2704
2705         ao2_unlock(callno_pool);
2706         return 0;
2707 }
2708
2709 static int callno_hash(const void *obj, const int flags)
2710 {
2711         return abs(ast_random());
2712 }
2713
2714 static int create_callno_pools(void)
2715 {
2716         uint16_t i;
2717
2718         if (!(callno_pool = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2719                 return -1;
2720         }
2721
2722         if (!(callno_pool_trunk = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2723                 return -1;
2724         }
2725
2726         /* start at 2, 0 and 1 are reserved */
2727         for (i = 2; i <= IAX_MAX_CALLS; i++) {
2728                 struct callno_entry *callno_entry;
2729
2730                 if (!(callno_entry = ao2_alloc(sizeof(*callno_entry), NULL))) {
2731                         return -1;
2732                 }
2733
2734                 callno_entry->callno = i;
2735
2736                 if (i < TRUNK_CALL_START) {
2737                         ao2_link(callno_pool, callno_entry);
2738                 } else {
2739                         ao2_link(callno_pool_trunk, callno_entry);
2740                 }
2741
2742                 ao2_ref(callno_entry, -1);
2743         }
2744
2745         return 0;
2746 }
2747
2748 /*!
2749  * \internal
2750  * \brief Schedules delayed removal of iax2_pvt call number data
2751  *
2752  * \note After MIN_REUSE_TIME has passed for a destroyed iax2_pvt, the callno is
2753  * avaliable again, and the address from the previous connection must be decremented
2754  * from the peercnts table.  This function schedules these operations to take place.
2755  */
2756 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry)
2757 {
2758         int i;
2759         struct peercnt *peercnt;
2760         struct peercnt tmp = {
2761                 .addr = sin->sin_addr.s_addr,
2762         };
2763
2764         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2765                 /* refcount is incremented with ao2_find.  keep that ref for the scheduler */
2766                 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_inet_ntoa(sin->sin_addr), MIN_REUSE_TIME);
2767                 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
2768                 if (i == -1) {
2769                         ao2_ref(peercnt, -1);
2770                 }
2771         }
2772
2773         iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, callno_entry);
2774 }
2775
2776 /*! 
2777  * \internal
2778  * \brief returns whether or not a frame is capable of starting a new IAX2 dialog. 
2779  *
2780  * \note For this implementation, inbound pokes should _NOT_ be capable of allocating
2781  * a new callno.
2782  */
2783 static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
2784 {
2785         if (frametype != AST_FRAME_IAX) {
2786                 return 0;
2787         }
2788         switch (subclass) {
2789         case IAX_COMMAND_NEW:
2790         case IAX_COMMAND_REGREQ:
2791         case IAX_COMMAND_FWDOWNL:
2792         case IAX_COMMAND_REGREL:
2793                 return 1;
2794         case IAX_COMMAND_POKE:
2795                 if (!inbound) {
2796                         return 1;
2797                 }
2798                 break;
2799         }
2800         return 0;
2801 }
2802
2803 /*
2804  * \note Calling this function while holding another pvt lock can cause a deadlock.
2805  */
2806 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
2807 {
2808         int res = 0;
2809         int x;
2810         /* this call is calltoken validated as long as it is either NEW_FORCE
2811          * or NEW_ALLOW_CALLTOKEN_VALIDATED */
2812         int validated = (new > NEW_ALLOW) ? 1 : 0;
2813         char host[80];
2814
2815         if (new <= NEW_ALLOW) {
2816                 if (callno) {
2817                         struct chan_iax2_pvt *pvt;
2818                         struct chan_iax2_pvt tmp_pvt = {
2819                                 .callno = dcallno,
2820                                 .peercallno = callno,
2821                                 .transfercallno = callno,
2822                                 /* hack!! */
2823                                 .frames_received = check_dcallno,
2824                         };
2825
2826                         memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
2827                         /* this works for finding normal call numbers not involving transfering */ 
2828                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2829                                 if (return_locked) {
2830                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2831                                 }
2832                                 res = pvt->callno;
2833                                 ao2_ref(pvt, -1);
2834                                 pvt = NULL;
2835                                 return res;
2836                         }
2837                         /* this searches for transfer call numbers that might not get caught otherwise */
2838                         memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
2839                         memcpy(&tmp_pvt.transfer, sin, sizeof(tmp_pvt.transfer));
2840                         if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2841                                 if (return_locked) {
2842                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2843                                 }
2844                                 res = pvt->callno;
2845                                 ao2_ref(pvt, -1);
2846                                 pvt = NULL;
2847                                 return res;
2848                         }
2849                 }
2850                         /* This will occur on the first response to a message that we initiated,
2851                  * such as a PING. */
2852                 if (dcallno) {
2853                         ast_mutex_lock(&iaxsl[dcallno]);
2854                 }
2855                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
2856                         iaxs[dcallno]->peercallno = callno;
2857                         res = dcallno;
2858                         store_by_peercallno(iaxs[dcallno]);
2859                         if (!res || !return_locked) {
2860                                 ast_mutex_unlock(&iaxsl[dcallno]);
2861                         }
2862                         return res;
2863                 }
2864                 if (dcallno) {
2865                         ast_mutex_unlock(&iaxsl[dcallno]);
2866                 }
2867         }
2868         if (!res && (new >= NEW_ALLOW)) {
2869                 struct callno_entry *callno_entry;
2870                 /* It may seem odd that we look through the peer list for a name for
2871                  * this *incoming* call.  Well, it is weird.  However, users don't
2872                  * have an IP address/port number that we can match against.  So,
2873                  * this is just checking for a peer that has that IP/port and
2874                  * assuming that we have a user of the same name.  This isn't always
2875                  * correct, but it will be changed if needed after authentication. */
2876                 if (!iax2_getpeername(*sin, host, sizeof(host)))
2877                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
2878
2879                 if (peercnt_add(sin)) {
2880                         /* This address has hit its callnumber limit.  When the limit
2881                          * is reached, the connection is not added to the peercnts table.*/
2882                         return 0;
2883                 }
2884
2885                 if (!(callno_entry = get_unused_callno(0, validated))) {
2886                         /* since we ran out of space, remove the peercnt
2887                          * entry we added earlier */
2888                         peercnt_remove_by_addr(sin);
2889                         ast_log(LOG_WARNING, "No more space\n");
2890                         return 0;
2891                 }
2892                 x = callno_entry->callno;
2893                 ast_mutex_lock(&iaxsl[x]);
2894
2895                 iaxs[x] = new_iax(sin, host);
2896                 if (iaxs[x]) {
2897                         if (iaxdebug)
2898                                 ast_debug(1, "Creating new call structure %d\n", x);
2899                         iaxs[x]->callno_entry = callno_entry;
2900                         iaxs[x]->sockfd = sockfd;
2901                         iaxs[x]->addr.sin_port = sin->sin_port;
2902                         iaxs[x]->addr.sin_family = sin->sin_family;
2903                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
2904                         iaxs[x]->peercallno = callno;
2905                         iaxs[x]->callno = x;
2906                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
2907                         iaxs[x]->expiry = min_reg_expire;
2908                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
2909                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
2910                         iaxs[x]->amaflags = amaflags;
2911                         ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
2912                         ast_string_field_set(iaxs[x], accountcode, accountcode);
2913                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
2914                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
2915                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
2916
2917                         if (iaxs[x]->peercallno) {
2918                                 store_by_peercallno(iaxs[x]);
2919                         }
2920                 } else {
2921                         ast_log(LOG_WARNING, "Out of resources\n");
2922                         ast_mutex_unlock(&iaxsl[x]);
2923                         replace_callno(callno_entry);
2924                         return 0;
2925                 }
2926                 if (!return_locked)
2927                         ast_mutex_unlock(&iaxsl[x]);
2928                 res = x;
2929         }
2930         return res;
2931 }
2932
2933 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) { 
2934         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
2935 }
2936
2937 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
2938
2939         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
2940 }
2941
2942 /*!
2943  * \brief Queue a frame to a call's owning asterisk channel
2944  *
2945  * \pre This function assumes that iaxsl[callno] is locked when called.
2946  *
2947  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2948  * was valid before calling it, it may no longer be valid after calling it.
2949  * This function may unlock and lock the mutex associated with this callno,
2950  * meaning that another thread may grab it and destroy the call.
2951  */
2952 static int iax2_queue_frame(int callno, struct ast_frame *f)
2953 {
2954         iax2_lock_owner(callno);
2955         if (iaxs[callno] && iaxs[callno]->owner) {
2956                 ast_queue_frame(iaxs[callno]->owner, f);
2957                 ast_channel_unlock(iaxs[callno]->owner);
2958         }
2959         return 0;
2960 }
2961
2962 /*!
2963  * \brief Queue a hangup frame on the ast_channel owner
2964  *
2965  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
2966  * is active for the given call number.
2967  *
2968  * \pre Assumes lock for callno is already held.
2969  *
2970  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2971  * was valid before calling it, it may no longer be valid after calling it.
2972  * This function may unlock and lock the mutex associated with this callno,
2973  * meaning that another thread may grab it and destroy the call.
2974  */
2975 static int iax2_queue_hangup(int callno)
2976 {
2977         iax2_lock_owner(callno);
2978         if (iaxs[callno] && iaxs[callno]->owner) {
2979                 ast_queue_hangup(iaxs[callno]->owner);
2980                 ast_channel_unlock(iaxs[callno]->owner);
2981         }
2982         return 0;
2983 }
2984
2985 /*!
2986  * \brief Queue a control frame on the ast_channel owner
2987  *
2988  * This function queues a control frame on the owner of the IAX2 pvt struct that
2989  * is active for the given call number.
2990  *
2991  * \pre Assumes lock for callno is already held.
2992  *
2993  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2994  * was valid before calling it, it may no longer be valid after calling it.
2995  * This function may unlock and lock the mutex associated with this callno,
2996  * meaning that another thread may grab it and destroy the call.
2997  */
2998 static int iax2_queue_control_data(int callno, 
2999         enum ast_control_frame_type control, const void *data, size_t datalen)
3000 {
3001         iax2_lock_owner(callno);
3002         if (iaxs[callno] && iaxs[callno]->owner) {
3003                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
3004                 ast_channel_unlock(iaxs[callno]->owner);
3005         }
3006         return 0;
3007 }
3008 static void destroy_firmware(struct iax_firmware *cur)
3009 {
3010         /* Close firmware */
3011         if (cur->fwh) {
3012                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
3013         }
3014         close(cur->fd);
3015         ast_free(cur);
3016 }
3017
3018 static int try_firmware(char *s)
3019 {
3020         struct stat stbuf;
3021         struct iax_firmware *cur = NULL;
3022         int ifd, fd, res, len, chunk;
3023         struct ast_iax2_firmware_header *fwh, fwh2;
3024         struct MD5Context md5;
3025         unsigned char sum[16], buf[1024];
3026         char *s2, *last;
3027
3028         if (!(s2 = alloca(strlen(s) + 100))) {
3029                 ast_log(LOG_WARNING, "Alloca failed!\n");
3030                 return -1;
3031         }
3032
3033         last = strrchr(s, '/');
3034         if (last)
3035                 last++;
3036         else
3037                 last = s;
3038
3039         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
3040
3041         if (stat(s, &stbuf) < 0) {
3042                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
3043                 return -1;
3044         }
3045
3046         /* Make sure it's not a directory */
3047         if (S_ISDIR(stbuf.st_mode))
3048                 return -1;
3049         ifd = open(s, O_RDONLY);
3050         if (ifd < 0) {
3051                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
3052                 return -1;
3053         }
3054         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
3055         if (fd < 0) {
3056                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
3057                 close(ifd);
3058                 return -1;
3059         }
3060         /* Unlink our newly created file */
3061         unlink(s2);
3062         
3063         /* Now copy the firmware into it */
3064         len = stbuf.st_size;
3065         while(len) {
3066                 chunk = len;
3067                 if (chunk > sizeof(buf))
3068                         chunk = sizeof(buf);
3069                 res = read(ifd, buf, chunk);
3070                 if (res != chunk) {
3071                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3072                         close(ifd);
3073                         close(fd);
3074                         return -1;
3075                 }
3076                 res = write(fd, buf, chunk);
3077                 if (res != chunk) {
3078                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3079                         close(ifd);
3080                         close(fd);
3081                         return -1;
3082                 }
3083                 len -= chunk;
3084         }
3085         close(ifd);
3086         /* Return to the beginning */
3087         lseek(fd, 0, SEEK_SET);
3088         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
3089                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
3090                 close(fd);
3091                 return -1;
3092         }
3093         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
3094                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
3095                 close(fd);
3096                 return -1;
3097         }
3098         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
3099                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
3100                 close(fd);
3101                 return -1;
3102         }
3103         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
3104                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
3105                 close(fd);
3106                 return -1;
3107         }
3108         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
3109         if (fwh == MAP_FAILED) {
3110                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
3111                 close(fd);
3112                 return -1;
3113         }
3114         MD5Init(&md5);
3115         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
3116         MD5Final(sum, &md5);
3117         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
3118                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
3119                 munmap((void*)fwh, stbuf.st_size);
3120                 close(fd);
3121                 return -1;
3122         }
3123
3124         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3125                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
3126                         /* Found a candidate */
3127                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
3128                                 /* The version we have on loaded is older, load this one instead */
3129                                 break;
3130                         /* This version is no newer than what we have.  Don't worry about it.
3131                            We'll consider it a proper load anyhow though */
3132                         munmap((void*)fwh, stbuf.st_size);
3133                         close(fd);
3134                         return 0;
3135                 }
3136         }
3137         
3138         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
3139                 cur->fd = -1;
3140                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
3141         }
3142         
3143         if (cur) {
3144                 if (cur->fwh)
3145                         munmap((void*)cur->fwh, cur->mmaplen);
3146                 if (cur->fd > -1)
3147                         close(cur->fd);
3148                 cur->fwh = fwh;
3149                 cur->fd = fd;
3150                 cur->mmaplen = stbuf.st_size;
3151                 cur->dead = 0;
3152         }
3153         
3154         return 0;
3155 }
3156
3157 static int iax_check_version(char *dev)
3158 {
3159         int res = 0;
3160         struct iax_firmware *cur = NULL;
3161
3162         if (ast_strlen_zero(dev))
3163                 return 0;
3164
3165         AST_LIST_LOCK(&firmwares);
3166         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3167                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
3168                         res = ntohs(cur->fwh->version);
3169                         break;
3170                 }
3171         }
3172         AST_LIST_UNLOCK(&firmwares);
3173
3174         return res;
3175 }
3176
3177 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
3178 {
3179         int res = -1;
3180         unsigned int bs = desc & 0xff;
3181         unsigned int start = (desc >> 8) & 0xffffff;
3182         unsigned int bytes;
3183         struct iax_firmware *cur;
3184
3185         if (ast_strlen_zero((char *)dev) || !bs)
3186                 return -1;
3187
3188         start *= bs;
3189         
3190         AST_LIST_LOCK(&firmwares);
3191         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3192                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
3193                         continue;
3194                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
3195                 if (start < ntohl(cur->fwh->datalen)) {
3196                         bytes = ntohl(cur->fwh->datalen) - start;
3197                         if (bytes > bs)
3198                                 bytes = bs;
3199                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
3200                 } else {
3201                         bytes = 0;
3202                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
3203                 }
3204                 if (bytes == bs)
3205                         res = 0;
3206                 else
3207                         res = 1;
3208                 break;
3209         }
3210         AST_LIST_UNLOCK(&firmwares);
3211
3212         return res;
3213 }
3214
3215
3216 static void reload_firmware(int unload)
3217 {
3218         struct iax_firmware *cur = NULL;
3219         DIR *fwd;
3220         struct dirent *de;
3221         char dir[256], fn[256];
3222
3223         AST_LIST_LOCK(&firmwares);
3224
3225         /* Mark all as dead */
3226         AST_LIST_TRAVERSE(&firmwares, cur, list)
3227                 cur->dead = 1;
3228
3229         /* Now that we have marked them dead... load new ones */
3230         if (!unload) {
3231                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
3232                 fwd = opendir(dir);
3233                 if (fwd) {
3234                         while((de = readdir(fwd))) {
3235                                 if (de->d_name[0] != '.') {
3236                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
3237                                         if (!try_firmware(fn)) {
3238                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
3239                                         }
3240                                 }
3241                         }
3242                         closedir(fwd);
3243                 } else 
3244                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
3245         }
3246
3247         /* Clean up leftovers */
3248         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
3249                 if (!cur->dead)
3250                         continue;
3251                 AST_LIST_REMOVE_CURRENT(list);
3252                 destroy_firmware(cur);
3253         }
3254         AST_LIST_TRAVERSE_SAFE_END;
3255
3256         AST_LIST_UNLOCK(&firmwares);
3257 }
3258
3259 /*!
3260  * \note This function assumes that iaxsl[callno] is locked when called.
3261  *
3262  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3263  * was valid before calling it, it may no longer be valid after calling it.
3264  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
3265  * associated with this callno, meaning that another thread may grab it and destroy the call.
3266  */
3267 static int __do_deliver(void *data)
3268 {
3269         /* Just deliver the packet by using queueing.  This is called by
3270           the IAX thread with the iaxsl lock held. */
3271         struct iax_frame *fr = data;
3272         fr->retrans = -1;
3273         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
3274         if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
3275                 iax2_queue_frame(fr->callno, &fr->af);
3276         /* Free our iax frame */
3277         iax2_frame_free(fr);
3278         /* And don't run again */
3279         return 0;
3280 }
3281
3282 static int handle_error(void)
3283 {
3284         /* XXX Ideally we should figure out why an error occurred and then abort those
3285            rather than continuing to try.  Unfortunately, the published interface does
3286            not seem to work XXX */
3287 #if 0
3288         struct sockaddr_in *sin;
3289         int res;
3290         struct msghdr m;
3291         struct sock_extended_err e;
3292         m.msg_name = NULL;
3293         m.msg_namelen = 0;
3294         m.msg_iov = NULL;
3295         m.msg_control = &e;
3296         m.msg_controllen = sizeof(e);
3297         m.msg_flags = 0;
3298         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
3299         if (res < 0)
3300                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
3301         else {
3302                 if (m.msg_controllen) {
3303                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
3304                         if (sin) 
3305                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
3306                         else
3307                                 ast_log(LOG_WARNING, "No address detected??\n");
3308                 } else {
3309                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
3310                 }
3311         }
3312 #endif
3313         return 0;
3314 }
3315
3316 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
3317 {
3318         int res;
3319         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
3320                                         sizeof(*sin));
3321         if (res < 0) {
3322                 ast_debug(1, "Received error: %s\n", strerror(errno));
3323                 handle_error();
3324         } else
3325                 res = 0;
3326         return res;
3327 }
3328
3329 static int send_packet(struct iax_frame *f)
3330 {
3331         int res;
3332         int callno = f->callno;
3333
3334         /* Don't send if there was an error, but return error instead */
3335         if (!callno || !iaxs[callno] || iaxs[callno]->error)
3336             return -1;
3337
3338         /* Called with iaxsl held */
3339         if (iaxdebug)
3340                 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));
3341
3342         if (f->transfer) {
3343                 if (iaxdebug)
3344                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
3345                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer, sizeof(iaxs[callno]->transfer));
3346         } else {
3347                 if (iaxdebug)
3348                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
3349                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr, sizeof(iaxs[callno]->addr));
3350         }
3351         if (res < 0) {
3352                 if (iaxdebug)
3353                         ast_debug(1, "Received error: %s\n", strerror(errno));
3354                 handle_error();
3355         } else
3356                 res = 0;
3357
3358         return res;
3359 }
3360
3361 /*!
3362  * \note Since this function calls iax2_queue_hangup(), the pvt struct
3363  *       for the given call number may disappear during its execution.
3364  */
3365 static int iax2_predestroy(int callno)
3366 {
3367         struct ast_channel *c = NULL;
3368         struct chan_iax2_pvt *pvt = iaxs[callno];
3369
3370         if (!pvt)
3371                 return -1;
3372
3373         if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
3374                 iax2_destroy_helper(pvt);
3375                 ast_set_flag64(pvt, IAX_ALREADYGONE);
3376         }
3377
3378         if ((c = pvt->owner)) {
3379                 ast_channel_tech_pvt_set(c, NULL);
3380                 iax2_queue_hangup(callno);
3381                 pvt->owner = NULL;
3382                 ast_module_unref(ast_module_info->self);
3383         }
3384
3385         return 0;
3386 }
3387
3388 static void iax2_destroy(int callno)
3389 {
3390         struct chan_iax2_pvt *pvt = NULL;
3391         struct ast_channel *owner = NULL;
3392
3393 retry:
3394         if ((pvt = iaxs[callno])) {
3395 #if 0
3396                 /* iax2_destroy_helper gets called from this function later on.  When
3397                  * called twice, we get the (previously) familiar FRACK! errors in
3398                  * devmode, from the scheduler.  An alternative to this approach is to
3399                  * reset the scheduler entries to -1 when they're deleted in
3400                  * iax2_destroy_helper().  That approach was previously decided to be
3401                  * "wrong" because "the memory is going to be deallocated anyway.  Why
3402                  * should we be resetting those values?" */
3403                 iax2_destroy_helper(pvt);
3404 #endif
3405         }
3406
3407         owner = pvt ? pvt->owner : NULL;
3408
3409         if (owner) {
3410                 if (ast_channel_trylock(owner)) {
3411                         ast_debug(3, "Avoiding IAX destroy deadlock\n");
3412                         DEADLOCK_AVOIDANCE(&iaxsl[callno]);
3413                         goto retry;
3414                 }
3415         }
3416
3417         if (!owner) {
3418                 iaxs[callno] = NULL;
3419         }
3420
3421         if (pvt) {
3422                 if (!owner) {
3423                         pvt->owner = NULL;
3424                 } else {
3425                         /* If there's an owner, prod it to give up */
3426                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
3427                          * because we already hold the owner channel lock. */
3428                         ast_queue_hangup(owner);
3429                 }
3430
3431                 if (pvt->peercallno) {
3432                         remove_by_peercallno(pvt);
3433                 }
3434
3435                 if (pvt->transfercallno) {
3436                         remove_by_transfercallno(pvt);
3437                 }
3438
3439                 if (!owner) {
3440                         ao2_ref(pvt, -1);
3441                         pvt = NULL;
3442                 }
3443         }
3444
3445         if (owner) {
3446                 ast_channel_unlock(owner);
3447         }
3448 }
3449
3450 static int update_packet(struct iax_frame *f)
3451 {
3452         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
3453         struct ast_iax2_full_hdr *fh = f->data;
3454         struct ast_frame af;
3455
3456         /* if frame is encrypted. decrypt before updating it. */
3457         if (f->encmethods) {
3458                 decode_frame(&f->mydcx, fh, &af, &f->datalen);
3459         }
3460         /* Mark this as a retransmission */
3461         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
3462         /* Update iseqno */
3463         f->iseqno = iaxs[f->callno]->iseqno;
3464         fh->iseqno = f->iseqno;
3465
3466         /* Now re-encrypt the frame */
3467         if (f->encmethods) {
3468         /* since this is a retransmit frame, create a new random padding
3469          * before re-encrypting. */
3470                 build_rand_pad(f->semirand, sizeof(f->semirand));
3471                 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
3472         }
3473         return 0;
3474 }
3475
3476 static int attempt_transmit(const void *data);
3477 static void __attempt_transmit(const void *data)
3478 {
3479         /* Attempt to transmit the frame to the remote peer...
3480            Called without iaxsl held. */
3481         struct iax_frame *f = (struct iax_frame *)data;
3482         int freeme = 0;
3483         int callno = f->callno;
3484         /* Make sure this call is still active */
3485         if (callno) 
3486                 ast_mutex_lock(&iaxsl[callno]);
3487         if (callno && iaxs[callno]) {
3488                 if ((f->retries < 0) /* Already ACK'd */ ||
3489                     (f->retries >= max_retries) /* Too many attempts */) {
3490                                 /* Record an error if we've transmitted too many times */
3491                                 if (f->retries >= max_retries) {
3492                                         if (f->transfer) {
3493                                                 /* Transfer timeout */
3494                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
3495                                         } else if (f->final) {
3496                                                 iax2_destroy(callno);
3497                                         } else {
3498                                                 if (iaxs[callno]->owner)
3499                                                         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);
3500                                                 iaxs[callno]->error = ETIMEDOUT;
3501                                                 if (iaxs[callno]->owner) {
3502                                                         struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
3503                                                         /* Hangup the fd */
3504                                                         iax2_queue_frame(callno, &fr); /* XXX */
3505                                                         /* Remember, owner could disappear */
3506                                                         if (iaxs[callno] && iaxs[callno]->owner)
3507                                                                 ast_channel_hangupcause_set(iaxs[callno]->owner, AST_CAUSE_DESTINATION_OUT_OF_ORDER);
3508                                                 } else {
3509                                                         if (iaxs[callno]->reg) {
3510                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
3511                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
3512                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
3513                                                         }
3514                                                         iax2_destroy(callno);
3515                                                 }
3516                                         }
3517
3518                                 }
3519                                 freeme = 1;
3520                 } else {
3521                         /* Update it if it needs it */
3522                         update_packet(f);
3523                         /* Attempt transmission */
3524                         send_packet(f);
3525                         f->retries++;
3526                         /* Try again later after 10 times as long */
3527                         f->retrytime *= 10;
3528                         if (f->retrytime > MAX_RETRY_TIME)
3529                                 f->retrytime = MAX_RETRY_TIME;
3530                         /* Transfer messages max out at one second */
3531                         if (f->transfer && (f->retrytime > 1000))
3532                                 f->retrytime = 1000;
3533                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
3534                 }
3535         } else {
3536                 /* Make sure it gets freed */
3537                 f->retries = -1;
3538                 freeme = 1;
3539         }
3540
3541         if (freeme) {
3542                 /* Don't attempt delivery, just remove it from the queue */
3543                 AST_LIST_REMOVE(&frame_queue[callno], f, list);
3544                 ast_mutex_unlock(&iaxsl[callno]);
3545                 f->retrans = -1; /* this is safe because this is the scheduled function */
3546                 /* Free the IAX frame */
3547                 iax2_frame_free(f);
3548         } else if (callno) {
3549                 ast_mutex_unlock(&iaxsl[callno]);
3550         }
3551 }
3552
3553 static int attempt_transmit(const void *data)
3554 {
3555 #ifdef SCHED_MULTITHREADED
3556         if (schedule_action(__attempt_transmit, data))
3557 #endif          
3558                 __attempt_transmit(data);
3559         return 0;
3560 }
3561
3562 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3563 {
3564         struct iax2_peer *peer = NULL;
3565         struct iax2_user *user = NULL;
3566         static const char * const choices[] = { "all", NULL };
3567         char *cmplt;
3568
3569         switch (cmd) {
3570         case CLI_INIT:
3571                 e->command = "iax2 prune realtime";
3572                 e->usage =
3573                         "Usage: iax2 prune realtime [<peername>|all]\n"
3574                         "       Prunes object(s) from the cache\n";
3575                 return NULL;
3576         case CLI_GENERATE:
3577                 if (a->pos == 3) {
3578                         cmplt = ast_cli_complete(a->word, choices, a->n);
3579                         if (!cmplt)
3580                                 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
3581                         return cmplt;
3582                 }
3583                 return NULL;
3584         }
3585         if (a->argc != 4)
3586                 return CLI_SHOWUSAGE;
3587         if (!strcmp(a->argv[3], "all")) {
3588                 prune_users();
3589                 prune_peers();
3590                 ast_cli(a->fd, "Cache flushed successfully.\n");
3591                 return CLI_SUCCESS;
3592         }
3593         peer = find_peer(a->argv[3], 0);
3594         user = find_user(a->argv[3]);
3595         if (peer || user) {
3596                 if (peer) {
3597                         if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
3598                                 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
3599                                 expire_registry(peer_ref(peer));
3600                                 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
3601                         } else {
3602                                 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
3603                         }
3604                         peer_unref(peer);
3605                 }
3606                 if (user) {
3607                         if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
3608                                 ast_set_flag64(user, IAX_RTAUTOCLEAR);
3609                                 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
3610                         } else {
3611                                 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
3612                         }
3613                         ao2_unlink(users,user);
3614                         user_unref(user);
3615                 }
3616         } else {
3617                 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
3618         }
3619
3620         return CLI_SUCCESS;
3621 }
3622
3623 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3624 {
3625         switch (cmd) {
3626         case CLI_INIT:
3627                 e->command = "iax2 test losspct";
3628                 e->usage =
3629                         "Usage: iax2 test losspct <percentage>\n"
3630                         "       For testing, throws away <percentage> percent of incoming packets\n";
3631                 return NULL;
3632         case CLI_GENERATE:
3633                 return NULL;
3634         }
3635         if (a->argc != 4)
3636                 return CLI_SHOWUSAGE;
3637
3638         test_losspct = atoi(a->argv[3]);
3639
3640         return CLI_SUCCESS;
3641 }
3642
3643 #ifdef IAXTESTS
3644 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3645 {
3646         switch (cmd) {
3647         case CLI_INIT:
3648                 e->command = "iax2 test late";
3649                 e->usage =
3650                         "Usage: iax2 test late <ms>\n"
3651                         "       For testing, count the next frame as <ms> ms late\n";
3652                 return NULL;
3653         case CLI_GENERATE:
3654                 return NULL;
3655         }
3656
3657         if (a->argc != 4)
3658                 return CLI_SHOWUSAGE;
3659
3660         test_late = atoi(a->argv[3]);
3661
3662         return CLI_SUCCESS;
3663 }
3664
3665 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3666 {
3667         switch (cmd) {
3668         case CLI_INIT:
3669                 e->command = "iax2 test resync";
3670                 e->usage =
3671                         "Usage: iax2 test resync <ms>\n"
3672                         "       For testing, adjust all future frames by <ms> ms\n";
3673                 return NULL;
3674         case CLI_GENERATE:
3675                 return NULL;
3676         }
3677
3678         if (a->argc != 4)
3679                 return CLI_SHOWUSAGE;
3680
3681         test_resync = atoi(a->argv[3]);
3682
3683         return CLI_SUCCESS;
3684 }
3685
3686 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3687 {
3688         switch (cmd) {
3689         case CLI_INIT:
3690                 e->command = "iax2 test jitter";
3691                 e->usage =
3692                         "Usage: iax2 test jitter <ms> <pct>\n"
3693                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
3694                         "       percentage of packets. If <pct> is not specified, adds\n"
3695                         "       jitter to all packets.\n";
3696                 return NULL;
3697         case CLI_GENERATE:
3698                 return NULL;
3699         }
3700
3701         if (a->argc < 4 || a->argc > 5)
3702                 return CLI_SHOWUSAGE;
3703
3704         test_jit = atoi(a->argv[3]);
3705         if (a->argc == 5)
3706                 test_jitpct = atoi(a->argv[4]);
3707
3708         return CLI_SUCCESS;
3709 }
3710 #endif /* IAXTESTS */
3711
3712 /*! \brief  peer_status: Report Peer status in character string */
3713 /*      returns 1 if peer is online, -1 if unmonitored */
3714 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
3715 {
3716         int res = 0;
3717         if (peer->maxms) {
3718                 if (peer->lastms < 0) {
3719                         ast_copy_string(status, "UNREACHABLE", statuslen);
3720                 } else if (peer->lastms > peer->maxms) {
3721                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
3722                         res = 1;
3723                 } else if (peer->lastms) {
3724                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
3725                         res = 1;
3726                 } else {
3727                         ast_copy_string(status, "UNKNOWN", statuslen);
3728                 }
3729         } else { 
3730                 ast_copy_string(status, "Unmonitored", statuslen);
3731                 res = -1;
3732         }
3733         return res;
3734 }
3735
3736 /*! \brief Show one peer in detail */
3737 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3738 {
3739         char status[30];
3740         char cbuf[256];
3741         struct iax2_peer *peer;
3742         char codec_buf[512];
3743         struct ast_str *encmethods = ast_str_alloca(256);
3744         int x = 0, load_realtime = 0;
3745
3746         switch (cmd) {
3747         case CLI_INIT:
3748                 e->command = "iax2 show peer";
3749                 e->usage =