Named ACLs: Introduces a system for creating and sharing ACLs
[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 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         if (!(s2 = alloca(strlen(s) + 100))) {
3088                 ast_log(LOG_WARNING, "Alloca failed!\n");
3089                 return -1;
3090         }
3091
3092         last = strrchr(s, '/');
3093         if (last)
3094                 last++;
3095         else
3096                 last = s;
3097
3098         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
3099
3100         if (stat(s, &stbuf) < 0) {
3101                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
3102                 return -1;
3103         }
3104
3105         /* Make sure it's not a directory */
3106         if (S_ISDIR(stbuf.st_mode))
3107                 return -1;
3108         ifd = open(s, O_RDONLY);
3109         if (ifd < 0) {
3110                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
3111                 return -1;
3112         }
3113         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
3114         if (fd < 0) {
3115                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
3116                 close(ifd);
3117                 return -1;
3118         }
3119         /* Unlink our newly created file */
3120         unlink(s2);
3121         
3122         /* Now copy the firmware into it */
3123         len = stbuf.st_size;
3124         while(len) {
3125                 chunk = len;
3126                 if (chunk > sizeof(buf))
3127                         chunk = sizeof(buf);
3128                 res = read(ifd, buf, chunk);
3129                 if (res != chunk) {
3130                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3131                         close(ifd);
3132                         close(fd);
3133                         return -1;
3134                 }
3135                 res = write(fd, buf, chunk);
3136                 if (res != chunk) {
3137                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3138                         close(ifd);
3139                         close(fd);
3140                         return -1;
3141                 }
3142                 len -= chunk;
3143         }
3144         close(ifd);
3145         /* Return to the beginning */
3146         lseek(fd, 0, SEEK_SET);
3147         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
3148                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
3149                 close(fd);
3150                 return -1;
3151         }
3152         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
3153                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
3154                 close(fd);
3155                 return -1;
3156         }
3157         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
3158                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
3159                 close(fd);
3160                 return -1;
3161         }
3162         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
3163                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
3164                 close(fd);
3165                 return -1;
3166         }
3167         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
3168         if (fwh == MAP_FAILED) {
3169                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
3170                 close(fd);
3171                 return -1;
3172         }
3173         MD5Init(&md5);
3174         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
3175         MD5Final(sum, &md5);
3176         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
3177                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
3178                 munmap((void*)fwh, stbuf.st_size);
3179                 close(fd);
3180                 return -1;
3181         }
3182
3183         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3184                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
3185                         /* Found a candidate */
3186                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
3187                                 /* The version we have on loaded is older, load this one instead */
3188                                 break;
3189                         /* This version is no newer than what we have.  Don't worry about it.
3190                            We'll consider it a proper load anyhow though */
3191                         munmap((void*)fwh, stbuf.st_size);
3192                         close(fd);
3193                         return 0;
3194                 }
3195         }
3196         
3197         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
3198                 cur->fd = -1;
3199                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
3200         }
3201         
3202         if (cur) {
3203                 if (cur->fwh)
3204                         munmap((void*)cur->fwh, cur->mmaplen);
3205                 if (cur->fd > -1)
3206                         close(cur->fd);
3207                 cur->fwh = fwh;
3208                 cur->fd = fd;
3209                 cur->mmaplen = stbuf.st_size;
3210                 cur->dead = 0;
3211         }
3212         
3213         return 0;
3214 }
3215
3216 static int iax_check_version(char *dev)
3217 {
3218         int res = 0;
3219         struct iax_firmware *cur = NULL;
3220
3221         if (ast_strlen_zero(dev))
3222                 return 0;
3223
3224         AST_LIST_LOCK(&firmwares);
3225         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3226                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
3227                         res = ntohs(cur->fwh->version);
3228                         break;
3229                 }
3230         }
3231         AST_LIST_UNLOCK(&firmwares);
3232
3233         return res;
3234 }
3235
3236 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
3237 {
3238         int res = -1;
3239         unsigned int bs = desc & 0xff;
3240         unsigned int start = (desc >> 8) & 0xffffff;
3241         unsigned int bytes;
3242         struct iax_firmware *cur;
3243
3244         if (ast_strlen_zero((char *)dev) || !bs)
3245                 return -1;
3246
3247         start *= bs;
3248         
3249         AST_LIST_LOCK(&firmwares);
3250         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3251                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
3252                         continue;
3253                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
3254                 if (start < ntohl(cur->fwh->datalen)) {
3255                         bytes = ntohl(cur->fwh->datalen) - start;
3256                         if (bytes > bs)
3257                                 bytes = bs;
3258                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
3259                 } else {
3260                         bytes = 0;
3261                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
3262                 }
3263                 if (bytes == bs)
3264                         res = 0;
3265                 else
3266                         res = 1;
3267                 break;
3268         }
3269         AST_LIST_UNLOCK(&firmwares);
3270
3271         return res;
3272 }
3273
3274
3275 static void reload_firmware(int unload)
3276 {