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