b36e24c343c316461217a20b38703e7166c9e766
[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 format_t 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 #define IAX_SHRINKCALLERID      (uint64_t)(1 << 31)   /*!< Turn on and off caller id shrinking */
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         format_t 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         format_t 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         format_t voiceformat;
643         /*! Last received video format */
644         format_t videoformat;
645         /*! Last sent voice format */
646         format_t svoiceformat;
647         /*! Last sent video format */
648         format_t svideoformat;
649         /*! What we are capable of sending */
650         format_t 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         format_t chosenformat;
685         /*! Peer selected format */
686         format_t peerformat;
687         /*! Peer capability */
688         format_t 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         /*! hold all signaling frames from the pbx thread until we have a destination callno */
824         char hold_signaling;
825         /*! frame queue for signaling frames from pbx thread waiting for destination callno */
826         AST_LIST_HEAD_NOLOCK(signaling_queue, signaling_queue_entry) signaling_queue;
827 };
828
829 struct signaling_queue_entry {
830         struct ast_frame f;
831         AST_LIST_ENTRY(signaling_queue_entry) next;
832 };
833
834 /*! table of available call numbers */
835 static struct ao2_container *callno_pool;
836
837 /*! table of available trunk call numbers */
838 static struct ao2_container *callno_pool_trunk;
839
840 static const unsigned int CALLNO_POOL_BUCKETS = 2699;
841
842 /*!
843  * \brief a list of frames that may need to be retransmitted
844  *
845  * \note The contents of this list do not need to be explicitly destroyed
846  * on module unload.  This is because all active calls are destroyed, and
847  * all frames in this queue will get destroyed as a part of that process.
848  *
849  * \note Contents protected by the iaxsl[] locks
850  */
851 static AST_LIST_HEAD_NOLOCK(, iax_frame) frame_queue[IAX_MAX_CALLS];
852
853 static struct ast_taskprocessor *transmit_processor;
854
855 static int randomcalltokendata;
856
857 static const time_t MAX_CALLTOKEN_DELAY = 10;
858
859 /*!
860  * This module will get much higher performance when doing a lot of
861  * user and peer lookups if the number of buckets is increased from 1.
862  * However, to maintain old behavior for Asterisk 1.4, these are set to
863  * 1 by default.  When using multiple buckets, search order through these
864  * containers is considered random, so you will not be able to depend on
865  * the order the entires are specified in iax.conf for matching order. */
866 #ifdef LOW_MEMORY
867 #define MAX_PEER_BUCKETS 17
868 #else
869 #define MAX_PEER_BUCKETS 563
870 #endif
871 static struct ao2_container *peers;
872
873 #define MAX_USER_BUCKETS MAX_PEER_BUCKETS
874 static struct ao2_container *users;
875
876 /*! Table containing peercnt objects for every ip address consuming a callno */
877 static struct ao2_container *peercnts;
878
879 /*! Table containing custom callno limit rules for a range of ip addresses. */
880 static struct ao2_container *callno_limits;
881
882 /*! Table containing ip addresses not requiring calltoken validation */
883 static struct ao2_container *calltoken_ignores;
884
885 static uint16_t DEFAULT_MAXCALLNO_LIMIT = 2048;
886
887 static uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192;
888
889 static uint16_t global_maxcallno;
890
891 /*! Total num of call numbers allowed to be allocated without calltoken validation */
892 static uint16_t global_maxcallno_nonval;
893
894 static uint16_t total_nonval_callno_used = 0;
895
896 /*! peer connection private, keeps track of all the call numbers
897  *  consumed by a single ip address */
898 struct peercnt {
899         /*! ip address consuming call numbers */
900         unsigned long addr;
901         /*! Number of call numbers currently used by this ip address */
902         uint16_t cur;
903         /*! Max call numbers allowed for this ip address */
904         uint16_t limit;
905         /*! Specifies whether limit is set by a registration or not, if so normal
906          *  limit setting rules do not apply to this address. */
907         unsigned char reg;
908 };
909
910 /*! used by both callno_limits and calltoken_ignores containers */
911 struct addr_range {
912         /*! ip address range for custom callno limit rule */
913         struct ast_ha ha;
914         /*! callno limit for this ip address range, only used in callno_limits container */
915         uint16_t limit;
916         /*! delete me marker for reloads */
917         unsigned char delme;
918 };
919
920 struct callno_entry {
921         /*! callno used for this entry */
922         uint16_t callno;
923         /*! was this callno calltoken validated or not */
924         unsigned char validated;
925 };
926
927 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
928
929 enum {
930         /*! Extension exists */
931         CACHE_FLAG_EXISTS      = (1 << 0),
932         /*! Extension is nonexistent */
933         CACHE_FLAG_NONEXISTENT = (1 << 1),
934         /*! Extension can exist */
935         CACHE_FLAG_CANEXIST    = (1 << 2),
936         /*! Waiting to hear back response */
937         CACHE_FLAG_PENDING     = (1 << 3),
938         /*! Timed out */
939         CACHE_FLAG_TIMEOUT     = (1 << 4),
940         /*! Request transmitted */
941         CACHE_FLAG_TRANSMITTED = (1 << 5),
942         /*! Timeout */
943         CACHE_FLAG_UNKNOWN     = (1 << 6),
944         /*! Matchmore */
945         CACHE_FLAG_MATCHMORE   = (1 << 7),
946 };
947
948 struct iax2_dpcache {
949         char peercontext[AST_MAX_CONTEXT];
950         char exten[AST_MAX_EXTENSION];
951         struct timeval orig;
952         struct timeval expiry;
953         int flags;
954         unsigned short callno;
955         int waiters[256];
956         AST_LIST_ENTRY(iax2_dpcache) cache_list;
957         AST_LIST_ENTRY(iax2_dpcache) peer_list;
958 };
959
960 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
961
962 static void reg_source_db(struct iax2_peer *p);
963 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
964 static struct iax2_user *realtime_user(const char *username, struct sockaddr_in *sin);
965
966 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
967 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags);
968 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
969
970 enum iax2_thread_iostate {
971         IAX_IOSTATE_IDLE,
972         IAX_IOSTATE_READY,
973         IAX_IOSTATE_PROCESSING,
974         IAX_IOSTATE_SCHEDREADY,
975 };
976
977 enum iax2_thread_type {
978         IAX_THREAD_TYPE_POOL,
979         IAX_THREAD_TYPE_DYNAMIC,
980 };
981
982 struct iax2_pkt_buf {
983         AST_LIST_ENTRY(iax2_pkt_buf) entry;
984         size_t len;
985         unsigned char buf[1];
986 };
987
988 struct iax2_thread {
989         AST_LIST_ENTRY(iax2_thread) list;
990         enum iax2_thread_type type;
991         enum iax2_thread_iostate iostate;
992 #ifdef SCHED_MULTITHREADED
993         void (*schedfunc)(const void *);
994         const void *scheddata;
995 #endif
996 #ifdef DEBUG_SCHED_MULTITHREAD
997         char curfunc[80];
998 #endif  
999         int actions;
1000         pthread_t threadid;
1001         int threadnum;
1002         struct sockaddr_in iosin;
1003         unsigned char readbuf[4096]; 
1004         unsigned char *buf;
1005         ssize_t buf_len;
1006         size_t buf_size;
1007         int iofd;
1008         time_t checktime;
1009         ast_mutex_t lock;
1010         ast_cond_t cond;
1011         ast_mutex_t init_lock;
1012         ast_cond_t init_cond;
1013         /*! if this thread is processing a full frame,
1014           some information about that frame will be stored
1015           here, so we can avoid dispatching any more full
1016           frames for that callno to other threads */
1017         struct {
1018                 unsigned short callno;
1019                 struct sockaddr_in sin;
1020                 unsigned char type;
1021                 unsigned char csub;
1022         } ffinfo;
1023         /*! Queued up full frames for processing.  If more full frames arrive for
1024          *  a call which this thread is already processing a full frame for, they
1025          *  are queued up here. */
1026         AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
1027 };
1028
1029 /* Thread lists */
1030 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
1031 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
1032 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
1033
1034 static void *iax2_process_thread(void *data);
1035 static void iax2_destroy(int callno);
1036
1037 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
1038 {
1039         ast_mutex_lock(lock);
1040         ast_cond_signal(cond);
1041         ast_mutex_unlock(lock);
1042 }
1043
1044 /*!
1045  * \brief an array of iax2 pvt structures
1046  *
1047  * The container for active chan_iax2_pvt structures is implemented as an
1048  * array for extremely quick direct access to the correct pvt structure
1049  * based on the local call number.  The local call number is used as the
1050  * index into the array where the associated pvt structure is stored.
1051  */
1052 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
1053
1054 /*!
1055  * \brief Another container of iax2_pvt structures
1056  *
1057  * Active IAX2 pvt structs are also stored in this container, if they are a part
1058  * of an active call where we know the remote side's call number.  The reason
1059  * for this is that incoming media frames do not contain our call number.  So,
1060  * instead of having to iterate the entire iaxs array, we use this container to
1061  * look up calls where the remote side is using a given call number.
1062  */
1063 static struct ao2_container *iax_peercallno_pvts;
1064
1065 /*!
1066  * \brief chan_iax2_pvt structure locks
1067  *
1068  * These locks are used when accessing a pvt structure in the iaxs array.
1069  * The index used here is the same as used in the iaxs array.  It is the
1070  * local call number for the associated pvt struct.
1071  */
1072 static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)];
1073
1074 /*!
1075  *  * \brief Another container of iax2_pvt structures
1076  *  
1077  *  Active IAX2 pvt stucts used during transfering a call are stored here.  
1078  */
1079 static struct ao2_container *iax_transfercallno_pvts;
1080
1081 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
1082    but keeps the division between trunked and non-trunked better. */
1083 #define TRUNK_CALL_START        ARRAY_LEN(iaxs) / 2
1084
1085 /* Debug routines... */
1086 static struct sockaddr_in debugaddr;
1087
1088 static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen)
1089 {
1090         if (iaxdebug ||
1091             (sin && debugaddr.sin_addr.s_addr && 
1092              (!ntohs(debugaddr.sin_port) ||
1093               debugaddr.sin_port == sin->sin_port) &&
1094              debugaddr.sin_addr.s_addr == sin->sin_addr.s_addr)) {
1095                 if (iaxdebug) {
1096                         iax_showframe(f, fhi, rx, sin, datalen);
1097                 } else {
1098                         iaxdebug = 1;
1099                         iax_showframe(f, fhi, rx, sin, datalen);
1100                         iaxdebug = 0;
1101                 }
1102         }
1103 }
1104
1105 static void iax_debug_output(const char *data)
1106 {
1107         if (iaxdebug)
1108                 ast_verbose("%s", data);
1109 }
1110
1111 static void iax_error_output(const char *data)
1112 {
1113         ast_log(LOG_WARNING, "%s", data);
1114 }
1115
1116 static void __attribute__((format(printf, 1, 2))) jb_error_output(const char *fmt, ...)
1117 {
1118         va_list args;
1119         char buf[1024];
1120
1121         va_start(args, fmt);
1122         vsnprintf(buf, sizeof(buf), fmt, args);
1123         va_end(args);
1124
1125         ast_log(LOG_ERROR, "%s", buf);
1126 }
1127
1128 static void __attribute__((format(printf, 1, 2))) jb_warning_output(const char *fmt, ...)
1129 {
1130         va_list args;
1131         char buf[1024];
1132
1133         va_start(args, fmt);
1134         vsnprintf(buf, sizeof(buf), fmt, args);
1135         va_end(args);
1136
1137         ast_log(LOG_WARNING, "%s", buf);
1138 }
1139
1140 static void __attribute__((format(printf, 1, 2))) jb_debug_output(const char *fmt, ...)
1141 {
1142         va_list args;
1143         char buf[1024];
1144
1145         va_start(args, fmt);
1146         vsnprintf(buf, sizeof(buf), fmt, args);
1147         va_end(args);
1148
1149         ast_verbose("%s", buf);
1150 }
1151
1152 static int maxtrunkcall = TRUNK_CALL_START;
1153 static int maxnontrunkcall = 1;
1154
1155 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);
1156 static int expire_registry(const void *data);
1157 static int iax2_answer(struct ast_channel *c);
1158 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
1159 static int iax2_devicestate(void *data);
1160 static int iax2_digit_begin(struct ast_channel *c, char digit);
1161 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
1162 static int iax2_do_register(struct iax2_registry *reg);
1163 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
1164 static int iax2_hangup(struct ast_channel *c);
1165 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
1166 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
1167 static int iax2_provision(struct sockaddr_in *end, int sockfd, const char *dest, const char *template, int force);
1168 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1169 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
1170 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
1171 static int iax2_sendtext(struct ast_channel *c, const char *text);
1172 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
1173 static int iax2_transfer(struct ast_channel *c, const char *dest);
1174 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
1175 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
1176 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1177 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1178 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1179 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
1180 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
1181 static struct ast_channel *iax2_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause);
1182 static struct ast_frame *iax2_read(struct ast_channel *c);
1183 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1184 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1185 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
1186 static void *iax2_dup_variable_datastore(void *);
1187 static void prune_peers(void);
1188 static void prune_users(void);
1189 static void iax2_free_variable_datastore(void *);
1190
1191 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
1192 static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen);
1193 static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen);
1194 static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt);
1195 static void build_rand_pad(unsigned char *buf, ssize_t len);
1196 static struct callno_entry *get_unused_callno(int trunk, int validated);
1197 static int replace_callno(const void *obj);
1198 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry);
1199
1200 static const struct ast_channel_tech iax2_tech = {
1201         .type = "IAX2",
1202         .description = tdesc,
1203         .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
1204         .properties = AST_CHAN_TP_WANTSJITTER,
1205         .requester = iax2_request,
1206         .devicestate = iax2_devicestate,
1207         .send_digit_begin = iax2_digit_begin,
1208         .send_digit_end = iax2_digit_end,
1209         .send_text = iax2_sendtext,
1210         .send_image = iax2_sendimage,
1211         .send_html = iax2_sendhtml,
1212         .call = iax2_call,
1213         .hangup = iax2_hangup,
1214         .answer = iax2_answer,
1215         .read = iax2_read,
1216         .write = iax2_write,
1217         .write_video = iax2_write,
1218         .indicate = iax2_indicate,
1219         .setoption = iax2_setoption,
1220         .bridge = iax2_bridge,
1221         .transfer = iax2_transfer,
1222         .fixup = iax2_fixup,
1223         .func_channel_read = acf_channel_read,
1224 };
1225
1226 static void mwi_event_cb(const struct ast_event *event, void *userdata)
1227 {
1228         /* The MWI subscriptions exist just so the core knows we care about those
1229          * mailboxes.  However, we just grab the events out of the cache when it
1230          * is time to send MWI, since it is only sent with a REGACK. */
1231 }
1232
1233 /*! \brief Send manager event at call setup to link between Asterisk channel name
1234         and IAX2 call identifiers */
1235 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt) 
1236 {
1237         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
1238                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
1239                 pvt->owner ? pvt->owner->name : "",
1240                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
1241 }
1242
1243
1244 static struct ast_datastore_info iax2_variable_datastore_info = {
1245         .type = "IAX2_VARIABLE",
1246         .duplicate = iax2_dup_variable_datastore,
1247         .destroy = iax2_free_variable_datastore,
1248 };
1249
1250 static void *iax2_dup_variable_datastore(void *old)
1251 {
1252         AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1253         struct ast_var_t *oldvar, *newvar;
1254
1255         newlist = ast_calloc(sizeof(*newlist), 1);
1256         if (!newlist) {
1257                 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1258                 return NULL;
1259         }
1260
1261         AST_LIST_HEAD_INIT(newlist);
1262         AST_LIST_LOCK(oldlist);
1263         AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1264                 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1265                 if (newvar)
1266                         AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1267                 else
1268                         ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1269         }
1270         AST_LIST_UNLOCK(oldlist);
1271         return newlist;
1272 }
1273
1274 static void iax2_free_variable_datastore(void *old)
1275 {
1276         AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1277         struct ast_var_t *oldvar;
1278
1279         AST_LIST_LOCK(oldlist);
1280         while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1281                 ast_free(oldvar);
1282         }
1283         AST_LIST_UNLOCK(oldlist);
1284         AST_LIST_HEAD_DESTROY(oldlist);
1285         ast_free(oldlist);
1286 }
1287
1288
1289 /* WARNING: insert_idle_thread should only ever be called within the
1290  * context of an iax2_process_thread() thread.
1291  */
1292 static void insert_idle_thread(struct iax2_thread *thread)
1293 {
1294         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1295                 AST_LIST_LOCK(&dynamic_list);
1296                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1297                 AST_LIST_UNLOCK(&dynamic_list);
1298         } else {
1299                 AST_LIST_LOCK(&idle_list);
1300                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1301                 AST_LIST_UNLOCK(&idle_list);
1302         }
1303
1304         return;
1305 }
1306
1307 static struct iax2_thread *find_idle_thread(void)
1308 {
1309         struct iax2_thread *thread = NULL;
1310
1311         /* Pop the head of the idle list off */
1312         AST_LIST_LOCK(&idle_list);
1313         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1314         AST_LIST_UNLOCK(&idle_list);
1315
1316         /* If we popped a thread off the idle list, just return it */
1317         if (thread) {
1318                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1319                 return thread;
1320         }
1321
1322         /* Pop the head of the dynamic list off */
1323         AST_LIST_LOCK(&dynamic_list);
1324         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1325         AST_LIST_UNLOCK(&dynamic_list);
1326
1327         /* If we popped a thread off the dynamic list, just return it */
1328         if (thread) {
1329                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1330                 return thread;
1331         }
1332
1333         /* If we can't create a new dynamic thread for any reason, return no thread at all */
1334         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1335                 return NULL;
1336
1337         /* Set default values */
1338         ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1339         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1340         thread->type = IAX_THREAD_TYPE_DYNAMIC;
1341
1342         /* Initialize lock and condition */
1343         ast_mutex_init(&thread->lock);
1344         ast_cond_init(&thread->cond, NULL);
1345         ast_mutex_init(&thread->init_lock);
1346         ast_cond_init(&thread->init_cond, NULL);
1347         ast_mutex_lock(&thread->init_lock);
1348
1349         /* Create thread and send it on it's way */
1350         if (ast_pthread_create_detached_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1351                 ast_cond_destroy(&thread->cond);
1352                 ast_mutex_destroy(&thread->lock);
1353                 ast_free(thread);
1354                 return NULL;
1355         }
1356
1357         /* this thread is not processing a full frame (since it is idle),
1358            so ensure that the field for the full frame call number is empty */
1359         memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1360
1361         /* Wait for the thread to be ready before returning it to the caller */
1362         ast_cond_wait(&thread->init_cond, &thread->init_lock);
1363
1364         /* Done with init_lock */
1365         ast_mutex_unlock(&thread->init_lock);
1366
1367         return thread;
1368 }
1369
1370 #ifdef SCHED_MULTITHREADED
1371 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1372 {
1373         struct iax2_thread *thread = NULL;
1374         static time_t lasterror;
1375         static time_t t;
1376
1377         thread = find_idle_thread();
1378
1379         if (thread != NULL) {
1380                 thread->schedfunc = func;
1381                 thread->scheddata = data;
1382                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1383 #ifdef DEBUG_SCHED_MULTITHREAD
1384                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1385 #endif
1386                 signal_condition(&thread->lock, &thread->cond);
1387                 return 0;
1388         }
1389         time(&t);
1390         if (t != lasterror) 
1391                 ast_debug(1, "Out of idle IAX2 threads for scheduling!\n");
1392         lasterror = t;
1393
1394         return -1;
1395 }
1396 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1397 #endif
1398
1399 static int iax2_sched_replace(int id, struct ast_sched_thread *st, int when, 
1400                 ast_sched_cb callback, const void *data)
1401 {
1402         ast_sched_thread_del(st, id);
1403
1404         return ast_sched_thread_add(st, when, callback, data);
1405 }
1406
1407 static int iax2_sched_add(struct ast_sched_thread *st, int when, 
1408                 ast_sched_cb callback, const void *data)
1409 {
1410         return ast_sched_thread_add(st, when, callback, data);
1411 }
1412
1413 static int send_ping(const void *data);
1414
1415 static void __send_ping(const void *data)
1416 {
1417         int callno = (long) data;
1418
1419         ast_mutex_lock(&iaxsl[callno]);
1420
1421         if (iaxs[callno]) {
1422                 if (iaxs[callno]->peercallno) {
1423                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1424                         iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1425                 } else {
1426                         /* I am the schedule, so I'm allowed to do this */
1427                         iaxs[callno]->pingid = -1;
1428                 }
1429         } else {
1430                 ast_debug(1, "I was supposed to send a PING with callno %d, but no such call exists.\n", callno);
1431         }
1432
1433         ast_mutex_unlock(&iaxsl[callno]);
1434 }
1435
1436 static int send_ping(const void *data)
1437 {
1438 #ifdef SCHED_MULTITHREADED
1439         if (schedule_action(__send_ping, data))
1440 #endif          
1441                 __send_ping(data);
1442
1443         return 0;
1444 }
1445
1446 static void encmethods_to_str(int e, struct ast_str *buf)
1447 {
1448         ast_str_set(&buf, 0, "(");
1449         if (e & IAX_ENCRYPT_AES128) {
1450                 ast_str_append(&buf, 0, "aes128");
1451         }
1452         if (e & IAX_ENCRYPT_KEYROTATE) {
1453                 ast_str_append(&buf, 0, ",keyrotate");
1454         }
1455         if (ast_str_strlen(buf) > 1) {
1456                 ast_str_append(&buf, 0, ")");
1457         } else {
1458                 ast_str_set(&buf, 0, "No");
1459         }
1460 }
1461
1462 static int get_encrypt_methods(const char *s)
1463 {
1464         int e;
1465         if (!strcasecmp(s, "aes128"))
1466                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1467         else if (ast_true(s))
1468                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1469         else
1470                 e = 0;
1471         return e;
1472 }
1473
1474 static int send_lagrq(const void *data);
1475
1476 static void __send_lagrq(const void *data)
1477 {
1478         int callno = (long) data;
1479
1480         ast_mutex_lock(&iaxsl[callno]);
1481
1482         if (iaxs[callno]) {
1483                 if (iaxs[callno]->peercallno) {
1484                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1485                         iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1486                 } else {
1487                         /* I am the schedule, so I'm allowed to do this */
1488                         iaxs[callno]->lagid = -1;
1489                 }
1490         } else {
1491                 ast_debug(1, "I was supposed to send a LAGRQ with callno %d, but no such call exists.\n", callno);
1492         }
1493
1494         ast_mutex_unlock(&iaxsl[callno]);
1495 }
1496
1497 static int send_lagrq(const void *data)
1498 {
1499 #ifdef SCHED_MULTITHREADED
1500         if (schedule_action(__send_lagrq, data))
1501 #endif          
1502                 __send_lagrq(data);
1503         
1504         return 0;
1505 }
1506
1507 static unsigned char compress_subclass(format_t subclass)
1508 {
1509         int x;
1510         int power=-1;
1511         /* If it's 64 or smaller, just return it */
1512         if (subclass < IAX_FLAG_SC_LOG)
1513                 return subclass;
1514         /* Otherwise find its power */
1515         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1516                 if (subclass & (1LL << x)) {
1517                         if (power > -1) {
1518                                 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
1519                                 return 0;
1520                         } else
1521                                 power = x;
1522                 }
1523         }
1524         return power | IAX_FLAG_SC_LOG;
1525 }
1526
1527 static format_t uncompress_subclass(unsigned char csub)
1528 {
1529         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1530         if (csub & IAX_FLAG_SC_LOG) {
1531                 /* special case for 'compressed' -1 */
1532                 if (csub == 0xff)
1533                         return -1;
1534                 else
1535                         return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1536         }
1537         else
1538                 return csub;
1539 }
1540
1541 /*!
1542  * \note The only member of the peer passed here guaranteed to be set is the name field
1543  */
1544 static int peer_hash_cb(const void *obj, const int flags)
1545 {
1546         const struct iax2_peer *peer = obj;
1547
1548         return ast_str_hash(peer->name);
1549 }
1550
1551 /*!
1552  * \note The only member of the peer passed here guaranteed to be set is the name field
1553  */
1554 static int peer_cmp_cb(void *obj, void *arg, int flags)
1555 {
1556         struct iax2_peer *peer = obj, *peer2 = arg;
1557
1558         return !strcmp(peer->name, peer2->name) ? CMP_MATCH | CMP_STOP : 0;
1559 }
1560
1561 /*!
1562  * \note The only member of the user passed here guaranteed to be set is the name field
1563  */
1564 static int user_hash_cb(const void *obj, const int flags)
1565 {
1566         const struct iax2_user *user = obj;
1567
1568         return ast_str_hash(user->name);
1569 }
1570
1571 /*!
1572  * \note The only member of the user passed here guaranteed to be set is the name field
1573  */
1574 static int user_cmp_cb(void *obj, void *arg, int flags)
1575 {
1576         struct iax2_user *user = obj, *user2 = arg;
1577
1578         return !strcmp(user->name, user2->name) ? CMP_MATCH | CMP_STOP : 0;
1579 }
1580
1581 /*!
1582  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
1583  *       so do not call it with a pvt lock held.
1584  */
1585 static struct iax2_peer *find_peer(const char *name, int realtime) 
1586 {
1587         struct iax2_peer *peer = NULL;
1588         struct iax2_peer tmp_peer = {
1589                 .name = name,
1590         };
1591
1592         peer = ao2_find(peers, &tmp_peer, OBJ_POINTER);
1593
1594         /* Now go for realtime if applicable */
1595         if(!peer && realtime)
1596                 peer = realtime_peer(name, NULL);
1597
1598         return peer;
1599 }
1600
1601 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
1602 {
1603         ao2_ref(peer, +1);
1604         return peer;
1605 }
1606
1607 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
1608 {
1609         ao2_ref(peer, -1);
1610         return NULL;
1611 }
1612
1613 static struct iax2_user *find_user(const char *name)
1614 {
1615         struct iax2_user tmp_user = {
1616                 .name = name,
1617         };
1618
1619         return ao2_find(users, &tmp_user, OBJ_POINTER);
1620 }
1621 static inline struct iax2_user *user_ref(struct iax2_user *user)
1622 {
1623         ao2_ref(user, +1);
1624         return user;
1625 }
1626
1627 static inline struct iax2_user *user_unref(struct iax2_user *user)
1628 {
1629         ao2_ref(user, -1);
1630         return NULL;
1631 }
1632
1633 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
1634 {
1635         struct iax2_peer *peer = NULL;
1636         int res = 0;
1637         struct ao2_iterator i;
1638
1639         i = ao2_iterator_init(peers, 0);
1640         while ((peer = ao2_iterator_next(&i))) {
1641                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1642                     (peer->addr.sin_port == sin.sin_port)) {
1643                         ast_copy_string(host, peer->name, len);
1644                         peer_unref(peer);
1645                         res = 1;
1646                         break;
1647                 }
1648                 peer_unref(peer);
1649         }
1650         ao2_iterator_destroy(&i);
1651
1652         if (!peer) {
1653                 peer = realtime_peer(NULL, &sin);
1654                 if (peer) {
1655                         ast_copy_string(host, peer->name, len);
1656                         peer_unref(peer);
1657                         res = 1;
1658                 }
1659         }
1660
1661         return res;
1662 }
1663
1664 /*!\note Assumes the lock on the pvt is already held, when
1665  * iax2_destroy_helper() is called. */
1666 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1667 {
1668         /* Decrement AUTHREQ count if needed */
1669         if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
1670                 struct iax2_user *user;
1671                 struct iax2_user tmp_user = {
1672                         .name = pvt->username,
1673                 };
1674
1675                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
1676                 if (user) {
1677                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
1678                         user_unref(user);
1679                 }
1680
1681                 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
1682         }
1683         /* No more pings or lagrq's */
1684         AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->pingid, &iaxsl[pvt->callno]);
1685         AST_SCHED_DEL_SPINLOCK(ast_sched_thread_get_context(sched), pvt->lagid, &iaxsl[pvt->callno]);
1686         ast_sched_thread_del(sched, pvt->autoid);
1687         ast_sched_thread_del(sched, pvt->authid);
1688         ast_sched_thread_del(sched, pvt->initid);
1689         ast_sched_thread_del(sched, pvt->jbid);
1690         ast_sched_thread_del(sched, pvt->keyrotateid);
1691 }
1692
1693 static void iax2_frame_free(struct iax_frame *fr)
1694 {
1695         ast_sched_thread_del(sched, fr->retrans);
1696         iax_frame_free(fr);
1697 }
1698
1699 static int scheduled_destroy(const void *vid)
1700 {
1701         unsigned short callno = PTR_TO_CALLNO(vid);
1702         ast_mutex_lock(&iaxsl[callno]);
1703         if (iaxs[callno]) {
1704                 if (option_debug) {
1705                         ast_log(LOG_DEBUG, "Really destroying %d now...\n", callno);
1706                 }
1707                 iax2_destroy(callno);
1708         }
1709         ast_mutex_unlock(&iaxsl[callno]);
1710         return 0;
1711 }
1712
1713 static void free_signaling_queue_entry(struct signaling_queue_entry *s)
1714 {
1715         ast_free(s->f.data.ptr);
1716         ast_free(s);
1717 }
1718
1719 /*! \brief This function must be called once we are sure the other side has
1720  *  given us a call number.  All signaling is held here until that point. */
1721 static void send_signaling(struct chan_iax2_pvt *pvt)
1722 {
1723         struct signaling_queue_entry *s = NULL;
1724
1725         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
1726                 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
1727                 free_signaling_queue_entry(s);
1728         }
1729         pvt->hold_signaling = 0;
1730 }
1731
1732 /*! \brief All frames other than that of type AST_FRAME_IAX must be held until
1733  *  we have received a destination call number. */
1734 static int queue_signalling(struct chan_iax2_pvt *pvt, struct ast_frame *f)
1735 {
1736         struct signaling_queue_entry *new;
1737
1738         if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
1739                 return 1; /* do not queue this frame */
1740         } else if (!(new = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
1741                 return -1;  /* out of memory */
1742         }
1743
1744         memcpy(&new->f, f, sizeof(new->f)); /* copy ast_frame into our queue entry */
1745
1746         if (new->f.datalen) { /* if there is data in this frame copy it over as well */
1747                 if (!(new->f.data.ptr = ast_calloc(1, new->f.datalen))) {
1748                         free_signaling_queue_entry(new);
1749                         return -1;
1750                 }
1751                 memcpy(new->f.data.ptr, f->data.ptr, sizeof(*new->f.data.ptr));
1752         }
1753         AST_LIST_INSERT_TAIL(&pvt->signaling_queue, new, next);
1754
1755         return 0;
1756 }
1757
1758 static void pvt_destructor(void *obj)
1759 {
1760         struct chan_iax2_pvt *pvt = obj;
1761         struct iax_frame *cur = NULL;
1762         struct signaling_queue_entry *s = NULL;
1763
1764         ast_mutex_lock(&iaxsl[pvt->callno]);
1765
1766         iax2_destroy_helper(pvt);
1767
1768         sched_delay_remove(&pvt->addr, pvt->callno_entry);
1769         pvt->callno_entry = NULL;
1770
1771         /* Already gone */
1772         ast_set_flag64(pvt, IAX_ALREADYGONE);
1773
1774         AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
1775                 /* Cancel any pending transmissions */
1776                 cur->retries = -1;
1777         }
1778
1779         ast_mutex_unlock(&iaxsl[pvt->callno]);
1780
1781         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
1782                 free_signaling_queue_entry(s);
1783         }
1784
1785         if (pvt->reg) {
1786                 pvt->reg->callno = 0;
1787         }
1788
1789         if (!pvt->owner) {
1790                 jb_frame frame;
1791                 if (pvt->vars) {
1792                     ast_variables_destroy(pvt->vars);
1793                     pvt->vars = NULL;
1794                 }
1795
1796                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
1797                         iax2_frame_free(frame.data);
1798                 }
1799
1800                 jb_destroy(pvt->jb);
1801                 ast_string_field_free_memory(pvt);
1802         }
1803 }
1804
1805 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1806 {
1807         struct chan_iax2_pvt *tmp;
1808         jb_conf jbconf;
1809
1810         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
1811                 return NULL;
1812         }
1813
1814         if (ast_string_field_init(tmp, 32)) {
1815                 ao2_ref(tmp, -1);
1816                 tmp = NULL;
1817                 return NULL;
1818         }
1819                 
1820         tmp->prefs = prefs;
1821         tmp->pingid = -1;
1822         tmp->lagid = -1;
1823         tmp->autoid = -1;
1824         tmp->authid = -1;
1825         tmp->initid = -1;
1826         tmp->keyrotateid = -1;
1827
1828         ast_string_field_set(tmp,exten, "s");
1829         ast_string_field_set(tmp,host, host);
1830
1831         tmp->jb = jb_new();
1832         tmp->jbid = -1;
1833         jbconf.max_jitterbuf = maxjitterbuffer;
1834         jbconf.resync_threshold = resyncthreshold;
1835         jbconf.max_contig_interp = maxjitterinterps;
1836         jbconf.target_extra = jittertargetextra;
1837         jb_setconf(tmp->jb,&jbconf);
1838
1839         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1840
1841         tmp->hold_signaling = 1;
1842         AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
1843
1844         return tmp;
1845 }
1846
1847 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1848 {
1849         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1850         if (new) {
1851                 size_t afdatalen = new->afdatalen;
1852                 memcpy(new, fr, sizeof(*new));
1853                 iax_frame_wrap(new, &fr->af);
1854                 new->afdatalen = afdatalen;
1855                 new->data = NULL;
1856                 new->datalen = 0;
1857                 new->direction = DIRECTION_INGRESS;
1858                 new->retrans = -1;
1859         }
1860         return new;
1861 }
1862 /* keep these defined in this order.  They are used in find_callno to
1863  * determine whether or not a new call number should be allowed. */
1864 enum {
1865         /* do not allow a new call number, only search ones in use for match */
1866         NEW_PREVENT = 0,
1867         /* search for match first, then allow a new one to be allocated */
1868         NEW_ALLOW = 1,
1869         /* do not search for match, force a new call number */
1870         NEW_FORCE = 2,
1871         /* do not search for match, force a new call number.  Signifies call number
1872          * has been calltoken validated */
1873         NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
1874 };
1875
1876 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
1877 {
1878         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1879                 (cur->addr.sin_port == sin->sin_port)) {
1880                 /* This is the main host */
1881                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
1882                          (check_dcallno ? dcallno == cur->callno : 1) ) {
1883                         /* That's us.  Be sure we keep track of the peer call number */
1884                         return 1;
1885                 }
1886         }
1887         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1888             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1889                 /* We're transferring */
1890                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1891                         return 1;
1892         }
1893         return 0;
1894 }
1895
1896 static void update_max_trunk(void)
1897 {
1898         int max = TRUNK_CALL_START;
1899         int x;
1900
1901         /* XXX Prolly don't need locks here XXX */
1902         for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
1903                 if (iaxs[x]) {
1904                         max = x + 1;
1905                 }
1906         }
1907
1908         maxtrunkcall = max;
1909         if (iaxdebug)
1910                 ast_debug(1, "New max trunk callno is %d\n", max);
1911 }
1912
1913 static void update_max_nontrunk(void)
1914 {
1915         int max = 1;
1916         int x;
1917         /* XXX Prolly don't need locks here XXX */
1918         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1919                 if (iaxs[x])
1920                         max = x + 1;
1921         }
1922         maxnontrunkcall = max;
1923         if (iaxdebug)
1924                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1925 }
1926
1927 static int make_trunk(unsigned short callno, int locked)
1928 {
1929         int x;
1930         int res= 0;
1931         struct callno_entry *callno_entry;
1932         if (iaxs[callno]->oseqno) {
1933                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1934                 return -1;
1935         }
1936         if (callno & TRUNK_CALL_START) {
1937                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1938                 return -1;
1939         }
1940
1941         if (!(callno_entry = get_unused_callno(1, iaxs[callno]->callno_entry->validated))) {
1942                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1943                 return -1;
1944         }
1945
1946         x = callno_entry->callno;
1947         ast_mutex_lock(&iaxsl[x]);
1948
1949         /*!
1950          * \note We delete these before switching the slot, because if
1951          * they fire in the meantime, they will generate a warning.
1952          */
1953         ast_sched_thread_del(sched, iaxs[callno]->pingid);
1954         ast_sched_thread_del(sched, iaxs[callno]->lagid);
1955         iaxs[x] = iaxs[callno];
1956         iaxs[x]->callno = x;
1957
1958         /* since we copied over the pvt from a different callno, make sure the old entry is replaced
1959          * before assigning the new one */
1960         if (iaxs[x]->callno_entry) {
1961                 iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, iaxs[x]->callno_entry);
1962         }
1963         iaxs[x]->callno_entry = callno_entry;
1964
1965         iaxs[callno] = NULL;
1966         /* Update the two timers that should have been started */
1967         iaxs[x]->pingid = iax2_sched_add(sched, 
1968                 ping_time * 1000, send_ping, (void *)(long)x);
1969         iaxs[x]->lagid = iax2_sched_add(sched, 
1970                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
1971
1972         if (locked)
1973                 ast_mutex_unlock(&iaxsl[callno]);
1974         res = x;
1975         if (!locked)
1976                 ast_mutex_unlock(&iaxsl[x]);
1977
1978         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1979         /* We move this call from a non-trunked to a trunked call */
1980         update_max_trunk();
1981         update_max_nontrunk();
1982         return res;
1983 }
1984
1985 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
1986 {
1987         if (!pvt->transfercallno) {
1988                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
1989                 return;
1990         }
1991
1992         ao2_link(iax_transfercallno_pvts, pvt);
1993 }
1994
1995 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
1996 {
1997         if (!pvt->transfercallno) {
1998                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
1999                 return;
2000         }
2001
2002         ao2_unlink(iax_transfercallno_pvts, pvt);
2003 }
2004 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
2005 {
2006         if (!pvt->peercallno) {
2007                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2008                 return;
2009         }
2010
2011         ao2_link(iax_peercallno_pvts, pvt);
2012 }
2013
2014 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
2015 {
2016         if (!pvt->peercallno) {
2017                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2018                 return;
2019         }
2020
2021         ao2_unlink(iax_peercallno_pvts, pvt);
2022 }
2023
2024 static int addr_range_delme_cb(void *obj, void *arg, int flags)
2025 {
2026         struct addr_range *lim = obj;
2027         lim->delme = 1;
2028         return 0;
2029 }
2030
2031 static int addr_range_hash_cb(const void *obj, const int flags)
2032 {
2033         const struct addr_range *lim = obj;
2034         return abs((int) lim->ha.netaddr.s_addr);
2035 }
2036
2037 static int addr_range_cmp_cb(void *obj, void *arg, int flags)
2038 {
2039         struct addr_range *lim1 = obj, *lim2 = arg;
2040         return ((lim1->ha.netaddr.s_addr == lim2->ha.netaddr.s_addr) &&
2041                 (lim1->ha.netmask.s_addr == lim2->ha.netmask.s_addr)) ?
2042                 CMP_MATCH | CMP_STOP : 0;
2043 }
2044
2045 static int peercnt_hash_cb(const void *obj, const int flags)
2046 {
2047         const struct peercnt *peercnt = obj;
2048         return abs((int) peercnt->addr);
2049 }
2050
2051 static int peercnt_cmp_cb(void *obj, void *arg, int flags)
2052 {
2053         struct peercnt *peercnt1 = obj, *peercnt2 = arg;
2054         return (peercnt1->addr == peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
2055 }
2056
2057 static int addr_range_match_address_cb(void *obj, void *arg, int flags)
2058 {
2059         struct addr_range *addr_range = obj;
2060         struct sockaddr_in *sin = arg;
2061
2062         if ((sin->sin_addr.s_addr & addr_range->ha.netmask.s_addr) == addr_range->ha.netaddr.s_addr) {
2063                 return CMP_MATCH | CMP_STOP;
2064         }
2065         return 0;
2066 }
2067
2068 /*! 
2069  * \internal
2070  *
2071  * \brief compares sin to calltoken_ignores table to determine if validation is required.
2072  */
2073 static int calltoken_required(struct sockaddr_in *sin, const char *name, int subclass)
2074 {
2075         struct addr_range *addr_range;
2076         struct iax2_peer *peer = NULL;
2077         struct iax2_user *user = NULL;
2078         /* if no username is given, check for guest accounts */
2079         const char *find = S_OR(name, "guest");
2080         int res = 1;  /* required by default */
2081         int optional = 0;
2082         enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2083         /* There are only two cases in which calltoken validation is not required.
2084          * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2085          *         the peer definition has not set the requirecalltoken option.
2086          * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2087          */
2088
2089         /* ----- Case 1 ----- */
2090         if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, sin))) {
2091                 ao2_ref(addr_range, -1);
2092                 optional = 1;
2093         }
2094
2095         /* ----- Case 2 ----- */
2096         if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2097                 calltoken_required = user->calltoken_required;
2098         } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, sin))) {
2099                 calltoken_required = user->calltoken_required;
2100         } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2101                 calltoken_required = peer->calltoken_required;
2102         } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, sin))) {
2103                 calltoken_required = peer->calltoken_required;
2104         }
2105
2106         if (peer) {
2107                 peer_unref(peer);
2108         }
2109         if (user) {
2110                 user_unref(user);
2111         }
2112
2113         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);
2114         if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2115                 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2116                 res = 0;
2117         }
2118
2119         return res;
2120 }
2121
2122 /*! 
2123  * \internal
2124  *
2125  * \brief set peercnt callno limit.
2126  *
2127  * \details 
2128  * First looks in custom definitions. If not found, global limit
2129  * is used.  Entries marked as reg already have
2130  * a custom limit set by a registration and are not modified.
2131  */
2132 static void set_peercnt_limit(struct peercnt *peercnt)
2133 {
2134         uint16_t limit = global_maxcallno;
2135         struct addr_range *addr_range;
2136         struct sockaddr_in sin = {
2137                 .sin_addr.s_addr = peercnt->addr,
2138         };
2139
2140
2141         if (peercnt->reg && peercnt->limit) {
2142                 return; /* this peercnt has a custom limit set by a registration */
2143         }
2144
2145         if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &sin))) {
2146                 limit = addr_range->limit;
2147                 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_inet_ntoa(sin.sin_addr));
2148                 ao2_ref(addr_range, -1);
2149         }
2150
2151         peercnt->limit = limit;
2152 }
2153
2154 /*! 
2155  * \internal
2156  * \brief sets limits for all peercnts in table. done on reload to reflect changes in conf.
2157  */
2158 static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
2159 {
2160         struct peercnt *peercnt = obj;
2161
2162         set_peercnt_limit(peercnt);
2163         ast_debug(1, "Reset limits for peercnts table\n");
2164
2165         return 0;
2166 }
2167
2168 /*! 
2169  * \internal
2170  * \brief returns match if delme is set. 
2171  */
2172 static int prune_addr_range_cb(void *obj, void *arg, int flags)
2173 {
2174         struct addr_range *addr_range = obj;
2175
2176         return addr_range->delme ? CMP_MATCH : 0;
2177 }
2178
2179 /*! 
2180  * \internal
2181  * \brief modifies peercnt entry in peercnts table. Used to set custom limit or mark a registered ip
2182  */
2183 static void peercnt_modify(unsigned char reg, uint16_t limit, struct sockaddr_in *sin)
2184 {
2185         /* this function turns off and on custom callno limits set by peer registration */
2186         struct peercnt *peercnt;
2187         struct peercnt tmp = {
2188                 .addr = sin->sin_addr.s_addr,
2189         };
2190
2191         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2192                 peercnt->reg = reg;
2193                 if (limit) {
2194                         peercnt->limit = limit;
2195                 } else {
2196                         set_peercnt_limit(peercnt);
2197                 }
2198                 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_inet_ntoa(sin->sin_addr), peercnt->limit, peercnt->reg);
2199                 ao2_ref(peercnt, -1); /* decrement ref from find */
2200         }
2201 }
2202
2203 /*! 
2204  * \internal
2205  * \brief adds an ip to the peercnts table, increments connection count if it already exists
2206  *
2207  * \details First searches for the address in the peercnts table.  If found
2208  * the current count is incremented.  If not found a new peercnt is allocated
2209  * and linked into the peercnts table with a call number count of 1.
2210  */
2211 static int peercnt_add(struct sockaddr_in *sin)
2212 {
2213         struct peercnt *peercnt;
2214         unsigned long addr = sin->sin_addr.s_addr;
2215         int res = 0;
2216         struct peercnt tmp = {
2217                 .addr = addr,
2218         };
2219
2220         /* Reasoning for peercnts container lock:  Two identical ip addresses
2221          * could be added by different threads at the "same time". Without the container
2222          * lock, both threads could alloc space for the same object and attempt
2223          * to link to table.  With the lock, one would create the object and link
2224          * to table while the other would find the already created peercnt object
2225          * rather than creating a new one. */
2226         ao2_lock(peercnts);
2227         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2228                 ao2_lock(peercnt);
2229         } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2230                 ao2_lock(peercnt);
2231                 /* create and set defaults */
2232                 peercnt->addr = addr;
2233                 set_peercnt_limit(peercnt);
2234                 /* guarantees it does not go away after unlocking table
2235                  * ao2_find automatically adds this */
2236                 ao2_link(peercnts, peercnt);
2237         } else {
2238                 ao2_unlock(peercnts);
2239                 return -1;
2240         }
2241
2242         /* check to see if the address has hit its callno limit.  If not increment cur. */
2243         if (peercnt->limit > peercnt->cur) {
2244                 peercnt->cur++;
2245                 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin->sin_addr));
2246         } else { /* max num call numbers for this peer has been reached! */
2247                 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_inet_ntoa(sin->sin_addr));
2248                 res = -1;
2249         }
2250
2251         /* clean up locks and ref count */
2252         ao2_unlock(peercnt);
2253         ao2_unlock(peercnts);
2254         ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2255
2256         return res;
2257 }
2258
2259 /*! 
2260  * \internal
2261  * \brief decrements a peercnts table entry
2262  */
2263 static void peercnt_remove(struct peercnt *peercnt)
2264 {
2265         struct sockaddr_in sin = {
2266                 .sin_addr.s_addr = peercnt->addr,
2267         };
2268
2269         if (peercnt) {
2270                 /* Container locked here since peercnt may be unlinked from list.  If left unlocked,
2271                  * peercnt_add could try and grab this entry from the table and modify it at the
2272                  * "same time" this thread attemps to unlink it.*/
2273                 ao2_lock(peercnts);
2274                 peercnt->cur--;
2275                 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin.sin_addr));
2276                 /* if this was the last connection from the peer remove it from table */
2277                 if (peercnt->cur == 0) {
2278                         ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2279                 }
2280                 ao2_unlock(peercnts);
2281         }
2282 }
2283
2284 /*! 
2285  * \internal
2286  * \brief called by scheduler to decrement object
2287  */
2288 static int peercnt_remove_cb(const void *obj)
2289 {
2290         struct peercnt *peercnt = (struct peercnt *) obj;
2291
2292         peercnt_remove(peercnt);
2293         ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2294
2295         return 0;
2296 }
2297
2298 /*! 
2299  * \internal
2300  * \brief decrements peercnts connection count, finds by addr
2301  */
2302 static int peercnt_remove_by_addr(struct sockaddr_in *sin)
2303 {
2304         struct peercnt *peercnt;
2305         struct peercnt tmp = {
2306                 .addr = sin->sin_addr.s_addr,
2307         };
2308
2309         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2310                 peercnt_remove(peercnt);
2311                 ao2_ref(peercnt, -1); /* decrement ref from find */
2312         }
2313         return 0;
2314 }
2315
2316 /*! 
2317  * \internal
2318  * \brief Create callno_limit entry based on configuration
2319  */
2320 static void build_callno_limits(struct ast_variable *v)
2321 {
2322         struct addr_range *addr_range = NULL;
2323         struct addr_range tmp;
2324         struct ast_ha *ha;
2325         int limit;
2326         int error;
2327         int found;
2328
2329         for (; v; v = v->next) {
2330                 limit = -1;
2331                 error = 0;
2332                 found = 0;
2333                 ha = ast_append_ha("permit", v->name, NULL, &error);
2334
2335                 /* check for valid config information */
2336                 if (error) {
2337                         ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2338                         continue;
2339                 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2340                         ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2341                         ast_free_ha(ha);
2342                         continue;
2343                 }
2344
2345                 ast_copy_ha(ha, &tmp.ha);
2346                 /* find or create the addr_range */
2347                 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2348                         ao2_lock(addr_range);
2349                         found = 1;
2350                 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2351                         ast_free_ha(ha);
2352                         return; /* out of memory */
2353                 }
2354
2355                 /* copy over config data into addr_range object */
2356                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2357                 ast_free_ha(ha); /* cleanup the tmp ha */
2358                 addr_range->limit = limit;
2359                 addr_range->delme = 0;
2360
2361                 /* cleanup */
2362                 if (found) {
2363                         ao2_unlock(addr_range);
2364                 } else {
2365                         ao2_link(callno_limits, addr_range);
2366                 }
2367                 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2368         }
2369 }
2370
2371 /*! 
2372  * \internal
2373  * \brief Create calltoken_ignores entry based on configuration
2374  */
2375 static int add_calltoken_ignore(const char *addr)
2376 {
2377         struct addr_range tmp;
2378         struct addr_range *addr_range = NULL;
2379         struct ast_ha *ha = NULL;
2380         int error = 0;
2381
2382         if (ast_strlen_zero(addr)) {
2383                 ast_log(LOG_WARNING, "invalid calltokenoptional %s\n", addr);
2384                 return -1;
2385         }
2386
2387         ha = ast_append_ha("permit", addr, NULL, &error);
2388
2389         /* check for valid config information */
2390         if (error) {
2391                 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2392                 return -1;
2393         }
2394
2395         ast_copy_ha(ha, &tmp.ha);
2396         /* find or create the addr_range */
2397         if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2398                 ao2_lock(addr_range);
2399                 addr_range->delme = 0;
2400                 ao2_unlock(addr_range);
2401         } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2402                 /* copy over config data into addr_range object */
2403                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2404                 ao2_link(calltoken_ignores, addr_range);
2405         } else {
2406                 ast_free_ha(ha);
2407                 return -1;
2408         }
2409
2410         ast_free_ha(ha);
2411         ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2412
2413         return 0;
2414 }
2415
2416 static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2417 {
2418         struct ao2_iterator i;
2419         struct peercnt *peercnt;
2420         struct sockaddr_in sin;
2421         int found = 0;
2422
2423         switch (cmd) {
2424         case CLI_INIT:
2425                 e->command = "iax2 show callnumber usage";
2426                 e->usage =
2427                         "Usage: iax2 show callnumber usage [IP address]\n"
2428                         "       Shows current IP addresses which are consuming iax2 call numbers\n";
2429                 return NULL;
2430         case CLI_GENERATE:
2431                 return NULL;
2432         case CLI_HANDLER:
2433                 if (a->argc < 4 || a->argc > 5)
2434                         return CLI_SHOWUSAGE;
2435
2436                 ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2437                 i = ao2_iterator_init(peercnts, 0);
2438                 while ((peercnt = ao2_iterator_next(&i))) {
2439                         sin.sin_addr.s_addr = peercnt->addr;
2440                         if (a->argc == 5 && (!strcasecmp(a->argv[4], ast_inet_ntoa(sin.sin_addr)))) {
2441                                         ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2442                                         found = 1;
2443                                         break;
2444                         } else {
2445                                 ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2446                         }
2447                         ao2_ref(peercnt, -1);
2448                 }
2449                 ao2_iterator_destroy(&i);
2450
2451                 if (a->argc == 4) {
2452                         ast_cli(a->fd, "\nNon-CallToken Validation Limit: %d\nNon-CallToken Validated: %d\n", global_maxcallno_nonval, total_nonval_callno_used);
2453                 } else if (a->argc == 5 && !found) {
2454                         ast_cli(a->fd, "No callnumber table entries for %s found\n", a->argv[4] );
2455                 }
2456
2457                 return CLI_SUCCESS;
2458         default:
2459                 return NULL;
2460         }
2461 }
2462
2463 static struct callno_entry *get_unused_callno(int trunk, int validated)
2464 {
2465         struct callno_entry *callno_entry = NULL;
2466         if ((!ao2_container_count(callno_pool) && !trunk) || (!ao2_container_count(callno_pool_trunk) && trunk)) {
2467                 ast_log(LOG_WARNING, "Out of CallNumbers\n");
2468                 /* Minor optimization for the extreme case. */
2469                 return NULL;
2470         }
2471
2472         /* the callno_pool container is locked here primarily to ensure thread
2473          * safety of the total_nonval_callno_used check and increment */
2474         ao2_lock(callno_pool);
2475
2476         /* only a certain number of nonvalidated call numbers should be allocated.
2477          * If there ever is an attack, this separates the calltoken validating
2478          * users from the non calltoken validating users. */
2479         if (!validated && (total_nonval_callno_used >= global_maxcallno_nonval)) {
2480                 ast_log(LOG_WARNING, "NON-CallToken callnumber limit is reached. Current:%d Max:%d\n", total_nonval_callno_used, global_maxcallno_nonval);
2481                 ao2_unlock(callno_pool);
2482                 return NULL;
2483         }
2484
2485         /* unlink the object from the container, taking over ownership
2486          * of the reference the container had to the object */
2487         callno_entry = ao2_find((trunk ? callno_pool_trunk : callno_pool), NULL, OBJ_POINTER | OBJ_UNLINK | OBJ_CONTINUE);
2488
2489         if (callno_entry) {
2490                 callno_entry->validated = validated;
2491                 if (!validated) {
2492                         total_nonval_callno_used++;
2493                 }
2494         }
2495
2496         ao2_unlock(callno_pool);
2497         return callno_entry;
2498 }
2499
2500 static int replace_callno(const void *obj)
2501 {
2502         struct callno_entry *callno_entry = (struct callno_entry *) obj;
2503
2504         /* the callno_pool container is locked here primarily to ensure thread
2505          * safety of the total_nonval_callno_used check and decrement */
2506         ao2_lock(callno_pool);
2507
2508         if (!callno_entry->validated && (total_nonval_callno_used != 0)) {
2509                 total_nonval_callno_used--;
2510         } else if (!callno_entry->validated && (total_nonval_callno_used == 0)) {
2511                 ast_log(LOG_ERROR, "Attempted to decrement total non calltoken validated callnumbers below zero... Callno is:%d \n", callno_entry->callno);
2512         }
2513
2514         if (callno_entry->callno < TRUNK_CALL_START) {
2515                 ao2_link(callno_pool, callno_entry);
2516         } else {
2517                 ao2_link(callno_pool_trunk, callno_entry);
2518         }
2519         ao2_ref(callno_entry, -1); /* only container ref remains */
2520
2521         ao2_unlock(callno_pool);
2522         return 0;
2523 }
2524
2525 static int callno_hash(const void *obj, const int flags)
2526 {
2527         return abs(ast_random());
2528 }
2529
2530 static int create_callno_pools(void)
2531 {
2532         uint16_t i;
2533
2534         if (!(callno_pool = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2535                 return -1;
2536         }
2537
2538         if (!(callno_pool_trunk = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2539                 return -1;
2540         }
2541
2542         /* start at 2, 0 and 1 are reserved */
2543         for (i = 2; i <= IAX_MAX_CALLS; i++) {
2544                 struct callno_entry *callno_entry;
2545
2546                 if (!(callno_entry = ao2_alloc(sizeof(*callno_entry), NULL))) {
2547                         return -1;
2548                 }
2549
2550                 callno_entry->callno = i;
2551
2552                 if (i < TRUNK_CALL_START) {
2553                         ao2_link(callno_pool, callno_entry);
2554                 } else {
2555                         ao2_link(callno_pool_trunk, callno_entry);
2556                 }
2557
2558                 ao2_ref(callno_entry, -1);
2559         }
2560
2561         return 0;
2562 }
2563
2564 /*!
2565  * \internal
2566  * \brief Schedules delayed removal of iax2_pvt call number data
2567  *
2568  * \note After MIN_REUSE_TIME has passed for a destroyed iax2_pvt, the callno is
2569  * avaliable again, and the address from the previous connection must be decremented
2570  * from the peercnts table.  This function schedules these operations to take place.
2571  */
2572 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry)
2573 {
2574         int i;
2575         struct peercnt *peercnt;
2576         struct peercnt tmp = {
2577                 .addr = sin->sin_addr.s_addr,
2578         };
2579
2580         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2581                 /* refcount is incremented with ao2_find.  keep that ref for the scheduler */
2582                 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_inet_ntoa(sin->sin_addr), MIN_REUSE_TIME);
2583                 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
2584                 if (i == -1) {
2585                         ao2_ref(peercnt, -1);
2586                 }
2587         }
2588
2589         iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, callno_entry);
2590 }
2591
2592 /*! 
2593  * \internal
2594  * \brief returns whether or not a frame is capable of starting a new IAX2 dialog. 
2595  *
2596  * \note For this implementation, inbound pokes should _NOT_ be capable of allocating
2597  * a new callno.
2598  */
2599 static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
2600 {
2601         if (frametype != AST_FRAME_IAX) {
2602                 return 0;
2603         }
2604         switch (subclass) {
2605         case IAX_COMMAND_NEW:
2606         case IAX_COMMAND_REGREQ:
2607         case IAX_COMMAND_FWDOWNL:
2608         case IAX_COMMAND_REGREL:
2609                 return 1;
2610         case IAX_COMMAND_POKE:
2611                 if (!inbound) {
2612                         return 1;
2613                 }
2614                 break;
2615         }
2616         return 0;
2617 }
2618
2619 /*
2620  * \note Calling this function while holding another pvt lock can cause a deadlock.
2621  */
2622 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
2623 {
2624         int res = 0;
2625         int x;
2626         /* this call is calltoken validated as long as it is either NEW_FORCE
2627          * or NEW_ALLOW_CALLTOKEN_VALIDATED */
2628         int validated = (new > NEW_ALLOW) ? 1 : 0;
2629         char host[80];
2630
2631         if (new <= NEW_ALLOW) {
2632                 if (callno) {
2633                         struct chan_iax2_pvt *pvt;
2634                         struct chan_iax2_pvt tmp_pvt = {
2635                                 .callno = dcallno,
2636                                 .peercallno = callno,
2637                                 .transfercallno = callno,
2638                                 /* hack!! */
2639                                 .frames_received = check_dcallno,
2640                         };
2641
2642                         memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
2643                         /* this works for finding normal call numbers not involving transfering */ 
2644                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2645                                 if (return_locked) {
2646                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2647                                 }
2648                                 res = pvt->callno;
2649                                 ao2_ref(pvt, -1);
2650                                 pvt = NULL;
2651                                 return res;
2652                         }
2653                         /* this searches for transfer call numbers that might not get caught otherwise */
2654                         memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
2655                         memcpy(&tmp_pvt.transfer, sin, sizeof(tmp_pvt.transfer));
2656                         if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2657                                 if (return_locked) {
2658                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2659                                 }
2660                                 res = pvt->callno;
2661                                 ao2_ref(pvt, -1);
2662                                 pvt = NULL;
2663                                 return res;
2664                         }
2665                 }
2666                         /* This will occur on the first response to a message that we initiated,
2667                  * such as a PING. */
2668                 if (dcallno) {
2669                         ast_mutex_lock(&iaxsl[dcallno]);
2670                 }
2671                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
2672                         iaxs[dcallno]->peercallno = callno;
2673                         res = dcallno;
2674                         store_by_peercallno(iaxs[dcallno]);
2675                         if (!res || !return_locked) {
2676                                 ast_mutex_unlock(&iaxsl[dcallno]);
2677                         }
2678                         return res;
2679                 }
2680                 if (dcallno) {
2681                         ast_mutex_unlock(&iaxsl[dcallno]);
2682                 }
2683 #ifdef IAX_OLD_FIND
2684                 /* If we get here, we SHOULD NOT find a call structure for this
2685                    callno; if we do, it means that there is a call structure that
2686                    has a peer callno but did NOT get entered into the hash table,
2687                    which is bad.
2688
2689                    If we find a call structure using this old, slow method, output a log
2690                    message so we'll know about it. After a few months of leaving this in
2691                    place, if we don't hear about people seeing these messages, we can
2692                    remove this code for good.
2693                 */
2694
2695                 for (x = 1; !res && x < maxnontrunkcall; x++) {
2696                         ast_mutex_lock(&iaxsl[x]);
2697                         if (iaxs[x]) {
2698                                 /* Look for an exact match */
2699                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
2700                                         res = x;
2701                                 }
2702                         }
2703                         if (!res || !return_locked)
2704                                 ast_mutex_unlock(&iaxsl[x]);
2705                 }
2706                 for (x = TRUNK_CALL_START; !res && x < maxtrunkcall; x++) {
2707                         ast_mutex_lock(&iaxsl[x]);
2708                         if (iaxs[x]) {
2709                                 /* Look for an exact match */
2710                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
2711                                         res = x;
2712                                 }
2713                         }
2714                         if (!res || !return_locked)
2715                                 ast_mutex_unlock(&iaxsl[x]);
2716                 }
2717 #endif
2718         }
2719         if (!res && (new >= NEW_ALLOW)) {
2720                 struct callno_entry *callno_entry;
2721                 /* It may seem odd that we look through the peer list for a name for
2722                  * this *incoming* call.  Well, it is weird.  However, users don't
2723                  * have an IP address/port number that we can match against.  So,
2724                  * this is just checking for a peer that has that IP/port and
2725                  * assuming that we have a user of the same name.  This isn't always
2726                  * correct, but it will be changed if needed after authentication. */
2727                 if (!iax2_getpeername(*sin, host, sizeof(host)))
2728                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
2729
2730                 if (peercnt_add(sin)) {
2731                         /* This address has hit its callnumber limit.  When the limit
2732                          * is reached, the connection is not added to the peercnts table.*/
2733                         return 0;
2734                 }
2735
2736                 if (!(callno_entry = get_unused_callno(0, validated))) {
2737                         /* since we ran out of space, remove the peercnt
2738                          * entry we added earlier */
2739                         peercnt_remove_by_addr(sin);
2740                         ast_log(LOG_WARNING, "No more space\n");
2741                         return 0;
2742                 }
2743                 x = callno_entry->callno;
2744                 ast_mutex_lock(&iaxsl[x]);
2745
2746                 iaxs[x] = new_iax(sin, host);
2747                 update_max_nontrunk();
2748                 if (iaxs[x]) {
2749                         if (iaxdebug)
2750                                 ast_debug(1, "Creating new call structure %d\n", x);
2751                         iaxs[x]->callno_entry = callno_entry;
2752                         iaxs[x]->sockfd = sockfd;
2753                         iaxs[x]->addr.sin_port = sin->sin_port;
2754                         iaxs[x]->addr.sin_family = sin->sin_family;
2755                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
2756                         iaxs[x]->peercallno = callno;
2757                         iaxs[x]->callno = x;
2758                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
2759                         iaxs[x]->expiry = min_reg_expire;
2760                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
2761                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
2762                         iaxs[x]->amaflags = amaflags;
2763                         ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
2764                         ast_string_field_set(iaxs[x], accountcode, accountcode);
2765                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
2766                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
2767                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
2768
2769                         if (iaxs[x]->peercallno) {
2770                                 store_by_peercallno(iaxs[x]);
2771                         }
2772                 } else {
2773                         ast_log(LOG_WARNING, "Out of resources\n");
2774                         ast_mutex_unlock(&iaxsl[x]);
2775                         replace_callno(callno_entry);
2776                         return 0;
2777                 }
2778                 if (!return_locked)
2779                         ast_mutex_unlock(&iaxsl[x]);
2780                 res = x;
2781         }
2782         return res;
2783 }
2784
2785 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
2786
2787         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
2788 }
2789
2790 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
2791
2792         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
2793 }
2794
2795 /*!
2796  * \brief Queue a frame to a call's owning asterisk channel
2797  *
2798  * \pre This function assumes that iaxsl[callno] is locked when called.
2799  *
2800  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2801  * was valid before calling it, it may no longer be valid after calling it.
2802  * This function may unlock and lock the mutex associated with this callno,
2803  * meaning that another thread may grab it and destroy the call.
2804  */
2805 static int iax2_queue_frame(int callno, struct ast_frame *f)
2806 {
2807         for (;;) {
2808                 if (iaxs[callno] && iaxs[callno]->owner) {
2809                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2810                                 /* Avoid deadlock by pausing and trying again */
2811                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2812                         } else {
2813                                 ast_queue_frame(iaxs[callno]->owner, f);
2814                                 ast_channel_unlock(iaxs[callno]->owner);
2815                                 break;
2816                         }
2817                 } else
2818                         break;
2819         }
2820         return 0;
2821 }
2822
2823 /*!
2824  * \brief Queue a hangup frame on the ast_channel owner
2825  *
2826  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
2827  * is active for the given call number.
2828  *
2829  * \pre Assumes lock for callno is already held.
2830  *
2831  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2832  * was valid before calling it, it may no longer be valid after calling it.
2833  * This function may unlock and lock the mutex associated with this callno,
2834  * meaning that another thread may grab it and destroy the call.
2835  */
2836 static int iax2_queue_hangup(int callno)
2837 {
2838         for (;;) {
2839                 if (iaxs[callno] && iaxs[callno]->owner) {
2840                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2841                                 /* Avoid deadlock by pausing and trying again */
2842                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2843                         } else {
2844                                 ast_queue_hangup(iaxs[callno]->owner);
2845                                 ast_channel_unlock(iaxs[callno]->owner);
2846                                 break;
2847                         }
2848                 } else
2849                         break;
2850         }
2851         return 0;
2852 }
2853
2854 /*!
2855  * \brief Queue a control frame on the ast_channel owner
2856  *
2857  * This function queues a control frame on the owner of the IAX2 pvt struct that
2858  * is active for the given call number.
2859  *
2860  * \pre Assumes lock for callno is already held.
2861  *
2862  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2863  * was valid before calling it, it may no longer be valid after calling it.
2864  * This function may unlock and lock the mutex associated with this callno,
2865  * meaning that another thread may grab it and destroy the call.
2866  */
2867 static int iax2_queue_control_data(int callno, 
2868         enum ast_control_frame_type control, const void *data, size_t datalen)
2869 {
2870         for (;;) {
2871                 if (iaxs[callno] && iaxs[callno]->owner) {
2872                         if (ast_channel_trylock(iaxs[callno]->owner)) {
2873                                 /* Avoid deadlock by pausing and trying again */
2874                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2875                         } else {
2876                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
2877                                 ast_channel_unlock(iaxs[callno]->owner);
2878                                 break;
2879                         }
2880                 } else
2881                         break;
2882         }
2883         return 0;
2884 }
2885 static void destroy_firmware(struct iax_firmware *cur)
2886 {
2887         /* Close firmware */
2888         if (cur->fwh) {
2889                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
2890         }
2891         close(cur->fd);
2892         ast_free(cur);
2893 }
2894
2895 static int try_firmware(char *s)
2896 {
2897         struct stat stbuf;
2898         struct iax_firmware *cur = NULL;
2899         int ifd, fd, res, len, chunk;
2900         struct ast_iax2_firmware_header *fwh, fwh2;
2901         struct MD5Context md5;
2902         unsigned char sum[16], buf[1024];
2903         char *s2, *last;
2904
2905         if (!(s2 = alloca(strlen(s) + 100))) {
2906                 ast_log(LOG_WARNING, "Alloca failed!\n");
2907                 return -1;
2908         }
2909
2910         last = strrchr(s, '/');
2911         if (last)
2912                 last++;
2913         else
2914                 last = s;
2915
2916         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
2917
2918         if ((res = stat(s, &stbuf) < 0)) {
2919                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
2920                 return -1;
2921         }
2922
2923         /* Make sure it's not a directory */
2924         if (S_ISDIR(stbuf.st_mode))
2925                 return -1;
2926         ifd = open(s, O_RDONLY);
2927         if (ifd < 0) {
2928                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
2929                 return -1;
2930         }
2931         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
2932         if (fd < 0) {
2933                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
2934                 close(ifd);
2935                 return -1;
2936         }
2937         /* Unlink our newly created file */
2938         unlink(s2);
2939         
2940         /* Now copy the firmware into it */
2941         len = stbuf.st_size;
2942         while(len) {
2943                 chunk = len;
2944                 if (chunk > sizeof(buf))
2945                         chunk = sizeof(buf);
2946                 res = read(ifd, buf, chunk);
2947                 if (res != chunk) {
2948                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
2949                         close(ifd);
2950                         close(fd);
2951                         return -1;
2952                 }
2953                 res = write(fd, buf, chunk);
2954                 if (res != chunk) {
2955                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
2956                         close(ifd);
2957                         close(fd);
2958                         return -1;
2959                 }
2960                 len -= chunk;
2961         }
2962         close(ifd);
2963         /* Return to the beginning */
2964         lseek(fd, 0, SEEK_SET);
2965         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
2966                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
2967                 close(fd);
2968                 return -1;
2969         }
2970         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
2971                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
2972                 close(fd);
2973                 return -1;
2974         }
2975         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
2976                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
2977                 close(fd);
2978                 return -1;
2979         }
2980         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
2981                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
2982                 close(fd);
2983                 return -1;
2984         }
2985         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
2986         if (fwh == MAP_FAILED) {
2987                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
2988                 close(fd);
2989                 return -1;
2990         }
2991         MD5Init(&md5);
2992         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
2993         MD5Final(sum, &md5);
2994         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
2995                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
2996                 munmap((void*)fwh, stbuf.st_size);
2997                 close(fd);
2998                 return -1;
2999         }
3000
3001         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3002                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
3003                         /* Found a candidate */
3004                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
3005                                 /* The version we have on loaded is older, load this one instead */
3006                                 break;
3007                         /* This version is no newer than what we have.  Don't worry about it.
3008                            We'll consider it a proper load anyhow though */
3009                         munmap((void*)fwh, stbuf.st_size);
3010                         close(fd);
3011                         return 0;
3012                 }
3013         }
3014         
3015         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
3016                 cur->fd = -1;
3017                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
3018         }
3019         
3020         if (cur) {
3021                 if (cur->fwh)
3022                         munmap((void*)cur->fwh, cur->mmaplen);
3023                 if (cur->fd > -1)
3024                         close(cur->fd);
3025                 cur->fwh = fwh;
3026                 cur->fd = fd;
3027                 cur->mmaplen = stbuf.st_size;
3028                 cur->dead = 0;
3029         }
3030         
3031         return 0;
3032 }
3033
3034 static int iax_check_version(char *dev)
3035 {
3036         int res = 0;
3037         struct iax_firmware *cur = NULL;
3038
3039         if (ast_strlen_zero(dev))
3040                 return 0;
3041
3042         AST_LIST_LOCK(&firmwares);
3043         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3044                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
3045                         res = ntohs(cur->fwh->version);
3046                         break;
3047                 }
3048         }
3049         AST_LIST_UNLOCK(&firmwares);
3050
3051         return res;
3052 }
3053
3054 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
3055 {
3056         int res = -1;
3057         unsigned int bs = desc & 0xff;
3058         unsigned int start = (desc >> 8) & 0xffffff;
3059         unsigned int bytes;
3060         struct iax_firmware *cur;
3061
3062         if (ast_strlen_zero((char *)dev) || !bs)
3063                 return -1;
3064
3065         start *= bs;
3066         
3067         AST_LIST_LOCK(&firmwares);
3068         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3069                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
3070                         continue;
3071                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
3072                 if (start < ntohl(cur->fwh->datalen)) {
3073                         bytes = ntohl(cur->fwh->datalen) - start;
3074                         if (bytes > bs)
3075                                 bytes = bs;
3076                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
3077                 } else {
3078                         bytes = 0;
3079                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
3080                 }
3081                 if (bytes == bs)
3082                         res = 0;
3083                 else
3084                         res = 1;
3085                 break;
3086         }
3087         AST_LIST_UNLOCK(&firmwares);
3088
3089         return res;
3090 }
3091
3092
3093 static void reload_firmware(int unload)
3094 {
3095         struct iax_firmware *cur = NULL;
3096         DIR *fwd;
3097         struct dirent *de;
3098         char dir[256], fn[256];
3099
3100         AST_LIST_LOCK(&firmwares);
3101
3102         /* Mark all as dead */
3103         AST_LIST_TRAVERSE(&firmwares, cur, list)
3104                 cur->dead = 1;
3105
3106         /* Now that we have marked them dead... load new ones */
3107         if (!unload) {
3108                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
3109                 fwd = opendir(dir);
3110                 if (fwd) {
3111                         while((de = readdir(fwd))) {
3112                                 if (de->d_name[0] != '.') {
3113                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
3114                                         if (!try_firmware(fn)) {
3115                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
3116                                         }
3117                                 }
3118                         }
3119                         closedir(fwd);
3120                 } else 
3121                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
3122         }
3123
3124         /* Clean up leftovers */
3125         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
3126                 if (!cur->dead)
3127                         continue;
3128                 AST_LIST_REMOVE_CURRENT(list);
3129                 destroy_firmware(cur);
3130         }
3131         AST_LIST_TRAVERSE_SAFE_END;
3132
3133         AST_LIST_UNLOCK(&firmwares);
3134 }
3135
3136 /*!
3137  * \note This function assumes that iaxsl[callno] is locked when called.
3138  *
3139  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3140  * was valid before calling it, it may no longer be valid after calling it.
3141  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
3142  * associated with this callno, meaning that another thread may grab it and destroy the call.
3143  */
3144 static int __do_deliver(void *data)
3145 {
3146         /* Just deliver the packet by using queueing.  This is called by
3147           the IAX thread with the iaxsl lock held. */
3148         struct iax_frame *fr = data;
3149         fr->retrans = -1;
3150         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
3151         if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
3152                 iax2_queue_frame(fr->callno, &fr->af);
3153         /* Free our iax frame */
3154         iax2_frame_free(fr);
3155         /* And don't run again */
3156         return 0;
3157 }
3158
3159 static int handle_error(void)
3160 {
3161         /* XXX Ideally we should figure out why an error occurred and then abort those
3162            rather than continuing to try.  Unfortunately, the published interface does
3163            not seem to work XXX */
3164 #if 0
3165         struct sockaddr_in *sin;
3166         int res;
3167         struct msghdr m;
3168         struct sock_extended_err e;
3169         m.msg_name = NULL;
3170         m.msg_namelen = 0;
3171         m.msg_iov = NULL;
3172         m.msg_control = &e;
3173         m.msg_controllen = sizeof(e);
3174         m.msg_flags = 0;
3175         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
3176         if (res < 0)
3177                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
3178         else {
3179                 if (m.msg_controllen) {
3180                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
3181                         if (sin) 
3182                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
3183                         else
3184                                 ast_log(LOG_WARNING, "No address detected??\n");
3185                 } else {
3186                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
3187                 }
3188         }
3189 #endif
3190         return 0;
3191 }
3192
3193 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
3194 {
3195         int res;
3196         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
3197                                         sizeof(*sin));
3198         if (res < 0) {
3199                 ast_debug(1, "Received error: %s\n", strerror(errno));
3200                 handle_error();
3201         } else
3202                 res = 0;
3203         return res;
3204 }
3205
3206 static int send_packet(struct iax_frame *f)
3207 {
3208         int res;
3209         int callno = f->callno;
3210
3211         /* Don't send if there was an error, but return error instead */
3212         if (!callno || !iaxs[callno] || iaxs[callno]->error)
3213             return -1;
3214         
3215         /* Called with iaxsl held */
3216         if (iaxdebug)
3217                 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));
3218         
3219         if (f->transfer) {
3220                 if (iaxdebug)
3221                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
3222                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer, sizeof(iaxs[callno]->transfer));
3223         } else {
3224                 if (iaxdebug)
3225                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
3226                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr, sizeof(iaxs[callno]->addr));
3227         }
3228         if (res < 0) {
3229                 if (iaxdebug)
3230                         ast_debug(1, "Received error: %s\n", strerror(errno));
3231                 handle_error();
3232         } else
3233                 res = 0;
3234
3235         return res;
3236 }
3237
3238 /*!
3239  * \note Since this function calls iax2_queue_hangup(), the pvt struct
3240  *       for the given call number may disappear during its execution.
3241  */
3242 static int iax2_predestroy(int callno)
3243 {
3244         struct ast_channel *c = NULL;
3245         struct chan_iax2_pvt *pvt = iaxs[callno];
3246
3247         if (!pvt)
3248                 return -1;
3249
3250         if (!ast_test_flag64(pvt, IAX_ALREADYGONE)) {
3251                 iax2_destroy_helper(pvt);
3252                 ast_set_flag64(pvt, IAX_ALREADYGONE);
3253         }
3254
3255         if ((c = pvt->owner)) {
3256                 c->tech_pvt = NULL;
3257                 iax2_queue_hangup(callno);
3258                 pvt->owner = NULL;
3259                 ast_module_unref(ast_module_info->self);
3260         }
3261
3262         return 0;
3263 }
3264
3265 static void iax2_destroy(int callno)
3266 {
3267         struct chan_iax2_pvt *pvt = NULL;
3268         struct ast_channel *owner = NULL;
3269
3270 retry:
3271         if ((pvt = iaxs[callno])) {
3272                 iax2_destroy_helper(pvt);
3273         }
3274
3275         owner = pvt ? pvt->owner : NULL;
3276
3277         if (owner) {
3278                 if (ast_channel_trylock(owner)) {
3279                         ast_debug(3, "Avoiding IAX destroy deadlock\n");
3280                         DEADLOCK_AVOIDANCE(&iaxsl[callno]);
3281                         goto retry;
3282                 }
3283         }
3284
3285         if (!owner) {
3286                 iaxs[callno] = NULL;
3287         }
3288
3289         if (pvt) {
3290                 if (!owner) {
3291                         pvt->owner = NULL;
3292                 } else {
3293                         /* If there's an owner, prod it to give up */
3294                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
3295                          * because we already hold the owner channel lock. */
3296                         ast_queue_hangup(owner);
3297                 }
3298
3299                 if (pvt->peercallno) {
3300                         remove_by_peercallno(pvt);
3301                 }
3302
3303                 if (pvt->transfercallno) {
3304                         remove_by_transfercallno(pvt);
3305                 }
3306
3307                 if (!owner) {
3308                         ao2_ref(pvt, -1);
3309                         pvt = NULL;
3310                 }
3311         }
3312
3313         if (owner) {
3314                 ast_channel_unlock(owner);
3315         }
3316
3317         if (callno & 0x4000) {
3318                 update_max_trunk();
3319         }
3320 }
3321
3322 static int update_packet(struct iax_frame *f)
3323 {
3324         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
3325         struct ast_iax2_full_hdr *fh = f->data;
3326         struct ast_frame af;
3327
3328         /* if frame is encrypted. decrypt before updating it. */
3329         if (f->encmethods) {
3330                 decode_frame(&f->mydcx, fh, &af, &f->datalen);
3331         }
3332         /* Mark this as a retransmission */
3333         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
3334         /* Update iseqno */
3335         f->iseqno = iaxs[f->callno]->iseqno;
3336         fh->iseqno = f->iseqno;
3337
3338         /* Now re-encrypt the frame */
3339         if (f->encmethods) {
3340         /* since this is a retransmit frame, create a new random padding
3341          * before re-encrypting. */
3342                 build_rand_pad(f->semirand, sizeof(f->semirand));
3343                 encrypt_frame(&f->ecx, fh, f->semirand, &f->datalen);
3344         }
3345         return 0;
3346 }
3347
3348 static int attempt_transmit(const void *data);
3349 static void __attempt_transmit(const void *data)
3350 {
3351         /* Attempt to transmit the frame to the remote peer...
3352            Called without iaxsl held. */
3353         struct iax_frame *f = (struct iax_frame *)data;
3354         int freeme = 0;
3355         int callno = f->callno;
3356         /* Make sure this call is still active */
3357         if (callno) 
3358                 ast_mutex_lock(&iaxsl[callno]);
3359         if (callno && iaxs[callno]) {
3360                 if ((f->retries < 0) /* Already ACK'd */ ||
3361                     (f->retries >= max_retries) /* Too many attempts */) {
3362                                 /* Record an error if we've transmitted too many times */
3363                                 if (f->retries >= max_retries) {
3364                                         if (f->transfer) {
3365                                                 /* Transfer timeout */
3366                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
3367                                         } else if (f->final) {
3368                                                 iax2_destroy(callno);
3369                                         } else {
3370                                                 if (iaxs[callno]->owner)
3371                                                         ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %u, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass.integer, f->ts, f->oseqno);
3372                                                 iaxs[callno]->error = ETIMEDOUT;
3373                                                 if (iaxs[callno]->owner) {
3374                                                         struct ast_frame fr = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
3375                                                         /* Hangup the fd */
3376                                                         iax2_queue_frame(callno, &fr); /* XXX */
3377                                                         /* Remember, owner could disappear */
3378                                                         if (iaxs[callno] && iaxs[callno]->owner)
3379                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
3380                                                 } else {
3381                                                         if (iaxs[callno]->reg) {
3382                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
3383                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
3384                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
3385                                                         }
3386                                                         iax2_destroy(callno);
3387                                                 }
3388                                         }
3389
3390                                 }
3391                                 freeme = 1;
3392                 } else {
3393                         /* Update it if it needs it */
3394                         update_packet(f);
3395                         /* Attempt transmission */
3396                         send_packet(f);
3397                         f->retries++;
3398                         /* Try again later after 10 times as long */
3399                         f->retrytime *= 10;
3400                         if (f->retrytime > MAX_RETRY_TIME)
3401                                 f->retrytime = MAX_RETRY_TIME;
3402                         /* Transfer messages max out at one second */
3403                         if (f->transfer && (f->retrytime > 1000))
3404                                 f->retrytime = 1000;
3405                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
3406                 }
3407         } else {
3408                 /* Make sure it gets freed */
3409                 f->retries = -1;
3410                 freeme = 1;
3411         }
3412
3413         if (freeme) {
3414                 /* Don't attempt delivery, just remove it from the queue */
3415                 AST_LIST_REMOVE(&frame_queue[callno], f, list);
3416                 ast_mutex_unlock(&iaxsl[callno]);
3417                 f->retrans = -1; /* this is safe because this is the scheduled function */
3418                 /* Free the IAX frame */
3419                 iax2_frame_free(f);
3420         } else if (callno) {
3421                 ast_mutex_unlock(&iaxsl[callno]);
3422         }
3423 }
3424
3425 static int attempt_transmit(const void *data)
3426 {
3427 #ifdef SCHED_MULTITHREADED
3428         if (schedule_action(__attempt_transmit, data))
3429 #endif          
3430                 __attempt_transmit(data);
3431         return 0;
3432 }
3433
3434 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3435 {
3436         struct iax2_peer *peer = NULL;
3437         struct iax2_user *user = NULL;
3438         static const char * const choices[] = { "all", NULL };
3439         char *cmplt;
3440
3441         switch (cmd) {
3442         case CLI_INIT:
3443                 e->command = "iax2 prune realtime";
3444                 e->usage =
3445                         "Usage: iax2 prune realtime [<peername>|all]\n"
3446                         "       Prunes object(s) from the cache\n";
3447                 return NULL;
3448         case CLI_GENERATE:
3449                 if (a->pos == 3) {
3450                         cmplt = ast_cli_complete(a->word, choices, a->n);
3451                         if (!cmplt)
3452                                 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
3453                         return cmplt;
3454                 }
3455                 return NULL;
3456         }
3457         if (a->argc != 4)
3458                 return CLI_SHOWUSAGE;
3459         if (!strcmp(a->argv[3], "all")) {
3460                 prune_users();
3461                 prune_peers();
3462                 ast_cli(a->fd, "Cache flushed successfully.\n");
3463                 return CLI_SUCCESS;
3464         }
3465         peer = find_peer(a->argv[3], 0);
3466         user = find_user(a->argv[3]);
3467         if (peer || user) {
3468                 if (peer) {
3469                         if (ast_test_flag64(peer, IAX_RTCACHEFRIENDS)) {
3470                                 ast_set_flag64(peer, IAX_RTAUTOCLEAR);
3471                                 expire_registry(peer_ref(peer));
3472                                 ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
3473                         } else {
3474                                 ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
3475                         }
3476                         peer_unref(peer);
3477                 }
3478                 if (user) {
3479                         if (ast_test_flag64(user, IAX_RTCACHEFRIENDS)) {
3480                                 ast_set_flag64(user, IAX_RTAUTOCLEAR);
3481                                 ast_cli(a->fd, "User %s was removed from the cache.\n", a->argv[3]);
3482                         } else {
3483                                 ast_cli(a->fd, "User %s is not eligible for this operation.\n", a->argv[3]);
3484                         }
3485                         ao2_unlink(users,user);
3486                         user_unref(user);
3487                 }
3488         } else {
3489                 ast_cli(a->fd, "%s was not found in the cache.\n", a->argv[3]);
3490         }
3491
3492         return CLI_SUCCESS;
3493 }
3494
3495 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3496 {
3497         switch (cmd) {
3498         case CLI_INIT:
3499                 e->command = "iax2 test losspct";
3500                 e->usage =
3501                         "Usage: iax2 test losspct <percentage>\n"
3502                         "       For testing, throws away <percentage> percent of incoming packets\n";
3503                 return NULL;
3504         case CLI_GENERATE:
3505                 return NULL;
3506         }
3507         if (a->argc != 4)
3508                 return CLI_SHOWUSAGE;
3509
3510         test_losspct = atoi(a->argv[3]);
3511
3512         return CLI_SUCCESS;
3513 }
3514
3515 #ifdef IAXTESTS
3516 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3517 {
3518         switch (cmd) {
3519         case CLI_INIT:
3520                 e->command = "iax2 test late";
3521                 e->usage =
3522                         "Usage: iax2 test late <ms>\n"
3523                         "       For testing, count the next frame as <ms> ms late\n";
3524                 return NULL;
3525         case CLI_GENERATE:
3526                 return NULL;
3527         }
3528
3529         if (a->argc != 4)
3530                 return CLI_SHOWUSAGE;
3531
3532         test_late = atoi(a->argv[3]);
3533
3534         return CLI_SUCCESS;
3535 }
3536
3537 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3538 {
3539         switch (cmd) {
3540         case CLI_INIT:
3541                 e->command = "iax2 test resync";
3542                 e->usage =
3543                         "Usage: iax2 test resync <ms>\n"
3544                         "       For testing, adjust all future frames by <ms> ms\n";
3545                 return NULL;
3546         case CLI_GENERATE:
3547                 return NULL;
3548         }
3549
3550         if (a->argc != 4)
3551                 return CLI_SHOWUSAGE;
3552
3553         test_resync = atoi(a->argv[3]);
3554
3555         return CLI_SUCCESS;
3556 }
3557
3558 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3559 {
3560         switch (cmd) {
3561         case CLI_INIT:
3562                 e->command = "iax2 test jitter";
3563                 e->usage =
3564                         "Usage: iax2 test jitter <ms> <pct>\n"
3565                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
3566                         "       percentage of packets. If <pct> is not specified, adds\n"
3567                         "       jitter to all packets.\n";
3568                 return NULL;
3569         case CLI_GENERATE:
3570                 return NULL;
3571         }
3572
3573         if (a->argc < 4 || a->argc > 5)
3574                 return CLI_SHOWUSAGE;
3575
3576         test_jit = atoi(a->argv[3]);
3577         if (a->argc == 5)
3578                 test_jitpct = atoi(a->argv[4]);
3579
3580         return CLI_SUCCESS;
3581 }
3582 #endif /* IAXTESTS */
3583
3584 /*! \brief  peer_status: Report Peer status in character string */
3585 /*      returns 1 if peer is online, -1 if unmonitored */
3586 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
3587 {
3588         int res = 0;
3589         if (peer->maxms) {
3590                 if (peer->lastms < 0) {
3591                         ast_copy_string(status, "UNREACHABLE", statuslen);
3592                 } else if (peer->lastms > peer->maxms) {
3593                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
3594                         res = 1;
3595                 } else if (peer->lastms) {
3596                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
3597                         res = 1;
3598                 } else {
3599                         ast_copy_string(status, "UNKNOWN", statuslen);
3600                 }
3601         } else { 
3602                 ast_copy_string(status, "Unmonitored", statuslen);
3603                 res = -1;
3604         }
3605         return res;
3606 }
3607
3608 /*! \brief Show one peer in detail */
3609 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3610 {
3611         char status[30];
3612         char cbuf[256];
3613         struct iax2_peer *peer;
3614         char codec_buf[512];
3615         struct ast_str *encmethods = ast_str_alloca(256);
3616         int x = 0, codec = 0, load_realtime = 0;
3617
3618         switch (cmd) {
3619         case CLI_INIT:
3620                 e->command = "iax2 show peer";
3621                 e->usage =
3622                         "Usage: iax2 show peer <name>\n"
3623                         "       Display details on specific IAX peer\n";
3624                 return NULL;
3625         case CLI_GENERATE:
3626                 if (a->pos == 3)
3627                         return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
3628                 return NULL;
3629         }
3630
3631         if (a->argc < 4)
3632                 return CLI_SHOWUSAGE;
3633
3634         load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
3635
3636         peer = find_peer(a->argv[3], load_realtime);
3637         if (peer) {
3638                 encmethods_to_str(peer->encmethods, encmethods);
3639                 ast_cli(a->fd, "\n\n");
3640                 ast_cli(a->fd, "  * Name       : %s\n", peer->name);
3641                 ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
3642                 ast_cli(a->fd, "  Context      : %s\n", peer->context);
3643                 ast_cli(a->fd, "  Parking lot  : %s\n", peer->parkinglot);
3644                 ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
3645                 ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag64(peer, IAX_DYNAMIC) ? "Yes" : "No");
3646                 ast_cli(a->fd, "  Callnum limit: %d\n", peer->maxcallno);
3647                 ast_cli(a->fd, "  Calltoken req: %s\n", (peer->calltoken_required == CALLTOKEN_YES) ? "Yes" : ((peer->calltoken_required == CALLTOKEN_AUTO) ? "Auto" : "No"));
3648                 ast_cli(a->fd, "  Trunk        : %s\n", ast_test_flag64(peer, IAX_TRUNK) ? "Yes" : "No");
3649                 ast_cli(a->fd, "  Encryption   : %s\n", peer->encmethods ? ast_str_buffer(encmethods) : "No");
3650                 ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
3651                 ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
3652                 ast_cli(a->fd, "  ACL          : %s\n", (peer->ha ? "Yes" : "No"));
3653                 ast_cli(a->fd, "  Addr->IP     : %s Port %d\n",  peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
3654                 ast_cli(a->fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
3655                 ast_cli(a->fd, "  Username     : %s\n", peer->username);
3656                 ast_cli(a->fd, "  Codecs       : ");
3657                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
3658                 ast_cli(a->fd, "%s\n", codec_buf);
3659
3660                 ast_cli(a->fd, "  Codec Order  : (");
3661                 for(x = 0; x < 32 ; x++) {
3662                         codec = ast_codec_pref_index(&peer->prefs,x);
3663                         if(!codec)
3664                                 break;
3665                         ast_cli(a->fd, "%s", ast_getformatname(codec));
3666                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
3667                                 ast_cli(a->fd, "|");
3668                 }
3669
3670                 if (!x)
3671                         ast_cli(a->fd, "none");
3672                 ast_cli(a->fd, ")\n");
3673
3674                 ast_cli(a->fd, "  Status       : ");
3675                 peer_status(peer, status, sizeof(status));      
3676                 ast_cli(a->fd, "%s\n",status);
3677                 ast_cli(a->fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
3678                 ast_cli(a->fd, "\n");
3679                 peer_unref(peer);
3680         } else {
3681                 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
3682                 ast_cli(a->fd, "\n");
3683         }
3684
3685         return CLI_SUCCESS;
3686 }
3687
3688 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags)
3689 {
3690         int which = 0;
3691         struct iax2_peer *peer;
3692         char *res = NULL;
3693         int wordlen = strlen(word);
3694         struct ao2_iterator i;
3695
3696         i = ao2_iterator_init(peers, 0);
3697         while ((peer = ao2_iterator_next(&i))) {
3698                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
3699                         && (!flags || ast_test_flag64(peer, flags))) {
3700                         res = ast_strdup(peer->name);
3701                         peer_unref(peer);
3702                         break;
3703                 }
3704                 peer_unref(peer);
3705         }
3706         ao2_iterator_destroy(&i);
3707
3708         return res;
3709 }
3710
3711 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3712 {
3713         struct iax_frame *cur;
3714         int cnt = 0, dea