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