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