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