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