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