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