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