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