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