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