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