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