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