(closes issue #13557)
[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 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1416 {
1417         /* Decrement AUTHREQ count if needed */
1418         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1419                 struct iax2_user *user;
1420                 struct iax2_user tmp_user = {
1421                         .name = pvt->username,
1422                 };
1423
1424                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
1425                 if (user) {
1426                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
1427                         user_unref(user);       
1428                 }
1429
1430                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1431         }
1432         /* No more pings or lagrq's */
1433         AST_SCHED_DEL(sched, pvt->pingid);
1434         AST_SCHED_DEL(sched, pvt->lagid);
1435         AST_SCHED_DEL(sched, pvt->autoid);
1436         AST_SCHED_DEL(sched, pvt->authid);
1437         AST_SCHED_DEL(sched, pvt->initid);
1438         AST_SCHED_DEL(sched, pvt->jbid);
1439         AST_SCHED_DEL(sched, pvt->keyrotateid);
1440 }
1441
1442 static void iax2_frame_free(struct iax_frame *fr)
1443 {
1444         AST_SCHED_DEL(sched, fr->retrans);
1445         iax_frame_free(fr);
1446 }
1447
1448 static void pvt_destructor(void *obj)
1449 {
1450         struct chan_iax2_pvt *pvt = obj;
1451         struct iax_frame *cur = NULL;
1452
1453         iax2_destroy_helper(pvt);
1454
1455         /* Already gone */
1456         ast_set_flag(pvt, IAX_ALREADYGONE);     
1457
1458         AST_LIST_LOCK(&frame_queue);
1459         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
1460                 /* Cancel any pending transmissions */
1461                 if (cur->callno == pvt->callno) { 
1462                         cur->retries = -1;
1463                 }
1464         }
1465         AST_LIST_UNLOCK(&frame_queue);
1466
1467         if (pvt->reg) {
1468                 pvt->reg->callno = 0;
1469         }
1470
1471         if (!pvt->owner) {
1472                 jb_frame frame;
1473                 if (pvt->vars) {
1474                     ast_variables_destroy(pvt->vars);
1475                     pvt->vars = NULL;
1476                 }
1477
1478                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
1479                         iax2_frame_free(frame.data);
1480                 }
1481
1482                 jb_destroy(pvt->jb);
1483                 ast_string_field_free_memory(pvt);
1484         }
1485 }
1486
1487 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1488 {
1489         struct chan_iax2_pvt *tmp;
1490         jb_conf jbconf;
1491
1492         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
1493                 return NULL;
1494         }
1495
1496         if (ast_string_field_init(tmp, 32)) {
1497                 ao2_ref(tmp, -1);
1498                 tmp = NULL;
1499                 return NULL;
1500         }
1501                 
1502         tmp->prefs = prefs;
1503         tmp->pingid = -1;
1504         tmp->lagid = -1;
1505         tmp->autoid = -1;
1506         tmp->authid = -1;
1507         tmp->initid = -1;
1508         tmp->keyrotateid = -1;
1509
1510         ast_string_field_set(tmp,exten, "s");
1511         ast_string_field_set(tmp,host, host);
1512
1513         tmp->jb = jb_new();
1514         tmp->jbid = -1;
1515         jbconf.max_jitterbuf = maxjitterbuffer;
1516         jbconf.resync_threshold = resyncthreshold;
1517         jbconf.max_contig_interp = maxjitterinterps;
1518         jbconf.target_extra = jittertargetextra;
1519         jb_setconf(tmp->jb,&jbconf);
1520
1521         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1522
1523         return tmp;
1524 }
1525
1526 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1527 {
1528         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1529         if (new) {
1530                 size_t afdatalen = new->afdatalen;
1531                 memcpy(new, fr, sizeof(*new));
1532                 iax_frame_wrap(new, &fr->af);
1533                 new->afdatalen = afdatalen;
1534                 new->data = NULL;
1535                 new->datalen = 0;
1536                 new->direction = DIRECTION_INGRESS;
1537                 new->retrans = -1;
1538         }
1539         return new;
1540 }
1541
1542 #define NEW_PREVENT     0
1543 #define NEW_ALLOW       1
1544 #define NEW_FORCE       2
1545
1546 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
1547 {
1548         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1549                 (cur->addr.sin_port == sin->sin_port)) {
1550                 /* This is the main host */
1551                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
1552                          (check_dcallno ? dcallno == cur->callno : 1) ) {
1553                         /* That's us.  Be sure we keep track of the peer call number */
1554                         return 1;
1555                 }
1556         }
1557         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1558             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1559                 /* We're transferring */
1560                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_NONE && cur->transfercallno == callno))
1561                         return 1;
1562         }
1563         return 0;
1564 }
1565
1566 static void update_max_trunk(void)
1567 {
1568         int max = TRUNK_CALL_START;
1569         int x;
1570
1571         /* XXX Prolly don't need locks here XXX */
1572         for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
1573                 if (iaxs[x]) {
1574                         max = x + 1;
1575                 }
1576         }
1577
1578         maxtrunkcall = max;
1579         if (iaxdebug)
1580                 ast_debug(1, "New max trunk callno is %d\n", max);
1581 }
1582
1583 static void update_max_nontrunk(void)
1584 {
1585         int max = 1;
1586         int x;
1587         /* XXX Prolly don't need locks here XXX */
1588         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1589                 if (iaxs[x])
1590                         max = x + 1;
1591         }
1592         maxnontrunkcall = max;
1593         if (iaxdebug)
1594                 ast_debug(1, "New max nontrunk callno is %d\n", max);
1595 }
1596
1597 static int make_trunk(unsigned short callno, int locked)
1598 {
1599         int x;
1600         int res= 0;
1601         struct timeval now = ast_tvnow();
1602         if (iaxs[callno]->oseqno) {
1603                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1604                 return -1;
1605         }
1606         if (callno & TRUNK_CALL_START) {
1607                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1608                 return -1;
1609         }
1610         for (x = TRUNK_CALL_START; x < ARRAY_LEN(iaxs) - 1; x++) {
1611                 ast_mutex_lock(&iaxsl[x]);
1612                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1613                         /*!
1614                          * \note We delete these before switching the slot, because if
1615                          * they fire in the meantime, they will generate a warning.
1616                          */
1617                         AST_SCHED_DEL(sched, iaxs[callno]->pingid);
1618                         AST_SCHED_DEL(sched, iaxs[callno]->lagid);
1619                         iaxs[x] = iaxs[callno];
1620                         iaxs[x]->callno = x;
1621                         iaxs[callno] = NULL;
1622                         /* Update the two timers that should have been started */
1623                         iaxs[x]->pingid = iax2_sched_add(sched, 
1624                                 ping_time * 1000, send_ping, (void *)(long)x);
1625                         iaxs[x]->lagid = iax2_sched_add(sched, 
1626                                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
1627                         if (locked)
1628                                 ast_mutex_unlock(&iaxsl[callno]);
1629                         res = x;
1630                         if (!locked)
1631                                 ast_mutex_unlock(&iaxsl[x]);
1632                         break;
1633                 }
1634                 ast_mutex_unlock(&iaxsl[x]);
1635         }
1636         if (x >= ARRAY_LEN(iaxs) - 1) {
1637                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1638                 return -1;
1639         }
1640         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1641         /* We move this call from a non-trunked to a trunked call */
1642         update_max_trunk();
1643         update_max_nontrunk();
1644         return res;
1645 }
1646
1647 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
1648 {
1649         if (!pvt->peercallno) {
1650                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
1651                 return;
1652         }
1653
1654         ao2_link(iax_peercallno_pvts, pvt);
1655 }
1656
1657 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
1658 {
1659         if (!pvt->peercallno) {
1660                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
1661                 return;
1662         }
1663
1664         ao2_unlink(iax_peercallno_pvts, pvt);
1665 }
1666
1667 /*
1668  * \note Calling this function while holding another pvt lock can cause a deadlock.
1669  */
1670 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
1671 {
1672         int res = 0;
1673         int x;
1674         struct timeval now;
1675         char host[80];
1676
1677         if (new <= NEW_ALLOW) {
1678                 if (callno) {
1679                         struct chan_iax2_pvt *pvt;
1680                         struct chan_iax2_pvt tmp_pvt = {
1681                                 .callno = dcallno,
1682                                 .peercallno = callno,
1683                                 /* hack!! */
1684                                 .frames_received = check_dcallno,
1685                         };
1686
1687                         memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
1688
1689                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
1690                                 if (return_locked) {
1691                                         ast_mutex_lock(&iaxsl[pvt->callno]);
1692                                 }
1693                                 res = pvt->callno;
1694                                 ao2_ref(pvt, -1);
1695                                 pvt = NULL;
1696                                 return res;
1697                         }
1698                 }
1699
1700                 /* This will occur on the first response to a message that we initiated,
1701                  * such as a PING. */
1702                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
1703                         iaxs[dcallno]->peercallno = callno;
1704                         res = dcallno;
1705                         store_by_peercallno(iaxs[dcallno]);
1706                         return res;
1707                 }
1708
1709 #ifdef IAX_OLD_FIND
1710                 /* If we get here, we SHOULD NOT find a call structure for this
1711                    callno; if we do, it means that there is a call structure that
1712                    has a peer callno but did NOT get entered into the hash table,
1713                    which is bad.
1714
1715                    If we find a call structure using this old, slow method, output a log
1716                    message so we'll know about it. After a few months of leaving this in
1717                    place, if we don't hear about people seeing these messages, we can
1718                    remove this code for good.
1719                 */
1720
1721                 for (x = 1; !res && x < maxnontrunkcall; x++) {
1722                         ast_mutex_lock(&iaxsl[x]);
1723                         if (iaxs[x]) {
1724                                 /* Look for an exact match */
1725                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
1726                                         res = x;
1727                                 }
1728                         }
1729                         if (!res || !return_locked)
1730                                 ast_mutex_unlock(&iaxsl[x]);
1731                 }
1732                 for (x = TRUNK_CALL_START; !res && x < maxtrunkcall; x++) {
1733                         ast_mutex_lock(&iaxsl[x]);
1734                         if (iaxs[x]) {
1735                                 /* Look for an exact match */
1736                                 if (match(sin, callno, dcallno, iaxs[x], check_dcallno)) {
1737                                         res = x;
1738                                 }
1739                         }
1740                         if (!res || !return_locked)
1741                                 ast_mutex_unlock(&iaxsl[x]);
1742                 }
1743 #endif
1744         }
1745         if (!res && (new >= NEW_ALLOW)) {
1746                 int start, found = 0;
1747
1748                 /* It may seem odd that we look through the peer list for a name for
1749                  * this *incoming* call.  Well, it is weird.  However, users don't
1750                  * have an IP address/port number that we can match against.  So,
1751                  * this is just checking for a peer that has that IP/port and
1752                  * assuming that we have a user of the same name.  This isn't always
1753                  * correct, but it will be changed if needed after authentication. */
1754                 if (!iax2_getpeername(*sin, host, sizeof(host)))
1755                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1756
1757                 now = ast_tvnow();
1758                 start = 2 + (ast_random() % (TRUNK_CALL_START - 1));
1759                 for (x = start; 1; x++) {
1760                         if (x == TRUNK_CALL_START) {
1761                                 x = 1;
1762                                 continue;
1763                         }
1764
1765                         /* Find first unused call number that hasn't been used in a while */
1766                         ast_mutex_lock(&iaxsl[x]);
1767                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1768                                 found = 1;
1769                                 break;
1770                         }
1771                         ast_mutex_unlock(&iaxsl[x]);
1772                         
1773                         if (x == start - 1) {
1774                                 break;
1775                         }
1776                 }
1777                 /* We've still got lock held if we found a spot */
1778                 if (x == start - 1 && !found) {
1779                         ast_log(LOG_WARNING, "No more space\n");
1780                         return 0;
1781                 }
1782                 iaxs[x] = new_iax(sin, host);
1783                 update_max_nontrunk();
1784                 if (iaxs[x]) {
1785                         if (iaxdebug)
1786                                 ast_debug(1, "Creating new call structure %d\n", x);
1787                         iaxs[x]->sockfd = sockfd;
1788                         iaxs[x]->addr.sin_port = sin->sin_port;
1789                         iaxs[x]->addr.sin_family = sin->sin_family;
1790                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1791                         iaxs[x]->peercallno = callno;
1792                         iaxs[x]->callno = x;
1793                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1794                         iaxs[x]->expiry = min_reg_expire;
1795                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1796                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1797                         iaxs[x]->amaflags = amaflags;
1798                         ast_copy_flags(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_NOKEYROTATE);
1799                         
1800                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1801                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1802                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1803                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
1804
1805                         if (iaxs[x]->peercallno) {
1806                                 store_by_peercallno(iaxs[x]);
1807                         }
1808                 } else {
1809                         ast_log(LOG_WARNING, "Out of resources\n");
1810                         ast_mutex_unlock(&iaxsl[x]);
1811                         return 0;
1812                 }
1813                 if (!return_locked)
1814                         ast_mutex_unlock(&iaxsl[x]);
1815                 res = x;
1816         }
1817         return res;
1818 }
1819
1820 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1821
1822         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
1823 }
1824
1825 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1826
1827         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
1828 }
1829
1830 /*!
1831  * \brief Queue a frame to a call's owning asterisk channel
1832  *
1833  * \pre This function assumes that iaxsl[callno] is locked when called.
1834  *
1835  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1836  * was valid before calling it, it may no longer be valid after calling it.
1837  * This function may unlock and lock the mutex associated with this callno,
1838  * meaning that another thread may grab it and destroy the call.
1839  */
1840 static int iax2_queue_frame(int callno, struct ast_frame *f)
1841 {
1842         for (;;) {
1843                 if (iaxs[callno] && iaxs[callno]->owner) {
1844                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1845                                 /* Avoid deadlock by pausing and trying again */
1846                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1847                         } else {
1848                                 ast_queue_frame(iaxs[callno]->owner, f);
1849                                 ast_channel_unlock(iaxs[callno]->owner);
1850                                 break;
1851                         }
1852                 } else
1853                         break;
1854         }
1855         return 0;
1856 }
1857
1858 /*!
1859  * \brief Queue a hangup frame on the ast_channel owner
1860  *
1861  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
1862  * is active for the given call number.
1863  *
1864  * \pre Assumes lock for callno is already held.
1865  *
1866  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1867  * was valid before calling it, it may no longer be valid after calling it.
1868  * This function may unlock and lock the mutex associated with this callno,
1869  * meaning that another thread may grab it and destroy the call.
1870  */
1871 static int iax2_queue_hangup(int callno)
1872 {
1873         for (;;) {
1874                 if (iaxs[callno] && iaxs[callno]->owner) {
1875                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1876                                 /* Avoid deadlock by pausing and trying again */
1877                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1878                         } else {
1879                                 ast_queue_hangup(iaxs[callno]->owner);
1880                                 ast_channel_unlock(iaxs[callno]->owner);
1881                                 break;
1882                         }
1883                 } else
1884                         break;
1885         }
1886         return 0;
1887 }
1888
1889 /*!
1890  * \brief Queue a control frame on the ast_channel owner
1891  *
1892  * This function queues a control frame on the owner of the IAX2 pvt struct that
1893  * is active for the given call number.
1894  *
1895  * \pre Assumes lock for callno is already held.
1896  *
1897  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1898  * was valid before calling it, it may no longer be valid after calling it.
1899  * This function may unlock and lock the mutex associated with this callno,
1900  * meaning that another thread may grab it and destroy the call.
1901  */
1902 static int iax2_queue_control_data(int callno, 
1903         enum ast_control_frame_type control, const void *data, size_t datalen)
1904 {
1905         for (;;) {
1906                 if (iaxs[callno] && iaxs[callno]->owner) {
1907                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1908                                 /* Avoid deadlock by pausing and trying again */
1909                                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1910                         } else {
1911                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
1912                                 ast_channel_unlock(iaxs[callno]->owner);
1913                                 break;
1914                         }
1915                 } else
1916                         break;
1917         }
1918         return 0;
1919 }
1920 static void destroy_firmware(struct iax_firmware *cur)
1921 {
1922         /* Close firmware */
1923         if (cur->fwh) {
1924                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1925         }
1926         close(cur->fd);
1927         ast_free(cur);
1928 }
1929
1930 static int try_firmware(char *s)
1931 {
1932         struct stat stbuf;
1933         struct iax_firmware *cur = NULL;
1934         int ifd, fd, res, len, chunk;
1935         struct ast_iax2_firmware_header *fwh, fwh2;
1936         struct MD5Context md5;
1937         unsigned char sum[16], buf[1024];
1938         char *s2, *last;
1939
1940         if (!(s2 = alloca(strlen(s) + 100))) {
1941                 ast_log(LOG_WARNING, "Alloca failed!\n");
1942                 return -1;
1943         }
1944
1945         last = strrchr(s, '/');
1946         if (last)
1947                 last++;
1948         else
1949                 last = s;
1950
1951         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1952
1953         if ((res = stat(s, &stbuf) < 0)) {
1954                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1955                 return -1;
1956         }
1957
1958         /* Make sure it's not a directory */
1959         if (S_ISDIR(stbuf.st_mode))
1960                 return -1;
1961         ifd = open(s, O_RDONLY);
1962         if (ifd < 0) {
1963                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1964                 return -1;
1965         }
1966         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1967         if (fd < 0) {
1968                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1969                 close(ifd);
1970                 return -1;
1971         }
1972         /* Unlink our newly created file */
1973         unlink(s2);
1974         
1975         /* Now copy the firmware into it */
1976         len = stbuf.st_size;
1977         while(len) {
1978                 chunk = len;
1979                 if (chunk > sizeof(buf))
1980                         chunk = sizeof(buf);
1981                 res = read(ifd, buf, chunk);
1982                 if (res != chunk) {
1983                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1984                         close(ifd);
1985                         close(fd);
1986                         return -1;
1987                 }
1988                 res = write(fd, buf, chunk);
1989                 if (res != chunk) {
1990                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1991                         close(ifd);
1992                         close(fd);
1993                         return -1;
1994                 }
1995                 len -= chunk;
1996         }
1997         close(ifd);
1998         /* Return to the beginning */
1999         lseek(fd, 0, SEEK_SET);
2000         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
2001                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
2002                 close(fd);
2003                 return -1;
2004         }
2005         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
2006                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
2007                 close(fd);
2008                 return -1;
2009         }
2010         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
2011                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
2012                 close(fd);
2013                 return -1;
2014         }
2015         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
2016                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
2017                 close(fd);
2018                 return -1;
2019         }
2020         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
2021         if (fwh == (void *) -1) {
2022                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
2023                 close(fd);
2024                 return -1;
2025         }
2026         MD5Init(&md5);
2027         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
2028         MD5Final(sum, &md5);
2029         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
2030                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
2031                 munmap((void*)fwh, stbuf.st_size);
2032                 close(fd);
2033                 return -1;
2034         }
2035
2036         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2037                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
2038                         /* Found a candidate */
2039                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
2040                                 /* The version we have on loaded is older, load this one instead */
2041                                 break;
2042                         /* This version is no newer than what we have.  Don't worry about it.
2043                            We'll consider it a proper load anyhow though */
2044                         munmap((void*)fwh, stbuf.st_size);
2045                         close(fd);
2046                         return 0;
2047                 }
2048         }
2049         
2050         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
2051                 cur->fd = -1;
2052                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
2053         }
2054         
2055         if (cur) {
2056                 if (cur->fwh)
2057                         munmap((void*)cur->fwh, cur->mmaplen);
2058                 if (cur->fd > -1)
2059                         close(cur->fd);
2060                 cur->fwh = fwh;
2061                 cur->fd = fd;
2062                 cur->mmaplen = stbuf.st_size;
2063                 cur->dead = 0;
2064         }
2065         
2066         return 0;
2067 }
2068
2069 static int iax_check_version(char *dev)
2070 {
2071         int res = 0;
2072         struct iax_firmware *cur = NULL;
2073
2074         if (ast_strlen_zero(dev))
2075                 return 0;
2076
2077         AST_LIST_LOCK(&firmwares);
2078         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2079                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
2080                         res = ntohs(cur->fwh->version);
2081                         break;
2082                 }
2083         }
2084         AST_LIST_UNLOCK(&firmwares);
2085
2086         return res;
2087 }
2088
2089 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
2090 {
2091         int res = -1;
2092         unsigned int bs = desc & 0xff;
2093         unsigned int start = (desc >> 8) & 0xffffff;
2094         unsigned int bytes;
2095         struct iax_firmware *cur;
2096
2097         if (ast_strlen_zero((char *)dev) || !bs)
2098                 return -1;
2099
2100         start *= bs;
2101         
2102         AST_LIST_LOCK(&firmwares);
2103         AST_LIST_TRAVERSE(&firmwares, cur, list) {
2104                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
2105                         continue;
2106                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
2107                 if (start < ntohl(cur->fwh->datalen)) {
2108                         bytes = ntohl(cur->fwh->datalen) - start;
2109                         if (bytes > bs)
2110                                 bytes = bs;
2111                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
2112                 } else {
2113                         bytes = 0;
2114                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
2115                 }
2116                 if (bytes == bs)
2117                         res = 0;
2118                 else
2119                         res = 1;
2120                 break;
2121         }
2122         AST_LIST_UNLOCK(&firmwares);
2123
2124         return res;
2125 }
2126
2127
2128 static void reload_firmware(int unload)
2129 {
2130         struct iax_firmware *cur = NULL;
2131         DIR *fwd;
2132         struct dirent *de;
2133         char dir[256], fn[256];
2134
2135         AST_LIST_LOCK(&firmwares);
2136
2137         /* Mark all as dead */
2138         AST_LIST_TRAVERSE(&firmwares, cur, list)
2139                 cur->dead = 1;
2140
2141         /* Now that we have marked them dead... load new ones */
2142         if (!unload) {
2143                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
2144                 fwd = opendir(dir);
2145                 if (fwd) {
2146                         while((de = readdir(fwd))) {
2147                                 if (de->d_name[0] != '.') {
2148                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
2149                                         if (!try_firmware(fn)) {
2150                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
2151                                         }
2152                                 }
2153                         }
2154                         closedir(fwd);
2155                 } else 
2156                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
2157         }
2158
2159         /* Clean up leftovers */
2160         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
2161                 if (!cur->dead)
2162                         continue;
2163                 AST_LIST_REMOVE_CURRENT(list);
2164                 destroy_firmware(cur);
2165         }
2166         AST_LIST_TRAVERSE_SAFE_END;
2167
2168         AST_LIST_UNLOCK(&firmwares);
2169 }
2170
2171 /*!
2172  * \note This function assumes that iaxsl[callno] is locked when called.
2173  *
2174  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2175  * was valid before calling it, it may no longer be valid after calling it.
2176  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
2177  * associated with this callno, meaning that another thread may grab it and destroy the call.
2178  */
2179 static int __do_deliver(void *data)
2180 {
2181         /* Just deliver the packet by using queueing.  This is called by
2182           the IAX thread with the iaxsl lock held. */
2183         struct iax_frame *fr = data;
2184         fr->retrans = -1;
2185         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
2186         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
2187                 iax2_queue_frame(fr->callno, &fr->af);
2188         /* Free our iax frame */
2189         iax2_frame_free(fr);
2190         /* And don't run again */
2191         return 0;
2192 }
2193
2194 static int handle_error(void)
2195 {
2196         /* XXX Ideally we should figure out why an error occurred and then abort those
2197            rather than continuing to try.  Unfortunately, the published interface does
2198            not seem to work XXX */
2199 #if 0
2200         struct sockaddr_in *sin;
2201         int res;
2202         struct msghdr m;
2203         struct sock_extended_err e;
2204         m.msg_name = NULL;
2205         m.msg_namelen = 0;
2206         m.msg_iov = NULL;
2207         m.msg_control = &e;
2208         m.msg_controllen = sizeof(e);
2209         m.msg_flags = 0;
2210         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
2211         if (res < 0)
2212                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
2213         else {
2214                 if (m.msg_controllen) {
2215                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
2216                         if (sin) 
2217                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
2218                         else
2219                                 ast_log(LOG_WARNING, "No address detected??\n");
2220                 } else {
2221                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
2222                 }
2223         }
2224 #endif
2225         return 0;
2226 }
2227
2228 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
2229 {
2230         int res;
2231         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
2232                                         sizeof(*sin));
2233         if (res < 0) {
2234                 ast_debug(1, "Received error: %s\n", strerror(errno));
2235                 handle_error();
2236         } else
2237                 res = 0;
2238         return res;
2239 }
2240
2241 static int send_packet(struct iax_frame *f)
2242 {
2243         int res;
2244         int callno = f->callno;
2245         struct sockaddr_in *addr;
2246
2247         /* Don't send if there was an error, but return error instead */
2248         if (!callno || !iaxs[callno] || iaxs[callno]->error)
2249             return -1;
2250         
2251         /* Called with iaxsl held */
2252         if (iaxdebug)
2253                 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));
2254
2255         if (f->media) {
2256                 addr = &iaxs[callno]->media;
2257         } else if (f->transfer) {
2258                 addr = &iaxs[callno]->transfer;
2259         } else {
2260                 addr = &iaxs[callno]->addr;
2261         }
2262         
2263         iax_outputframe(f, NULL, 0, addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
2264
2265         res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)addr, 
2266                      sizeof(iaxs[callno]->media));
2267
2268         if (res < 0) {
2269                 if (iaxdebug)
2270                         ast_debug(1, "Received error: %s\n", strerror(errno));
2271                 handle_error();
2272         } else
2273                 res = 0;
2274
2275         return res;
2276 }
2277
2278 /*!
2279  * \note Since this function calls iax2_queue_hangup(), the pvt struct
2280  *       for the given call number may disappear during its execution.
2281  */
2282 static int iax2_predestroy(int callno)
2283 {
2284         struct ast_channel *c = NULL;
2285         struct chan_iax2_pvt *pvt = iaxs[callno];
2286
2287         if (!pvt)
2288                 return -1;
2289
2290         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
2291                 iax2_destroy_helper(pvt);
2292                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2293         }
2294
2295         if ((c = pvt->owner)) {
2296                 c->tech_pvt = NULL;
2297                 iax2_queue_hangup(callno);
2298                 pvt->owner = NULL;
2299                 ast_module_unref(ast_module_info->self);
2300         }
2301
2302         return 0;
2303 }
2304
2305 static void iax2_destroy(int callno)
2306 {
2307         struct chan_iax2_pvt *pvt = NULL;
2308         struct ast_channel *owner = NULL;
2309
2310 retry:
2311         pvt = iaxs[callno];
2312         lastused[callno] = ast_tvnow();
2313         
2314         owner = pvt ? pvt->owner : NULL;
2315
2316         if (owner) {
2317                 if (ast_channel_trylock(owner)) {
2318                         ast_debug(3, "Avoiding IAX destroy deadlock\n");
2319                         DEADLOCK_AVOIDANCE(&iaxsl[callno]);
2320                         goto retry;
2321                 }
2322         }
2323
2324         if (!owner) {
2325                 iaxs[callno] = NULL;
2326         }
2327
2328         if (pvt) {
2329                 if (!owner) {
2330                         pvt->owner = NULL;
2331                 } else {
2332                         /* If there's an owner, prod it to give up */
2333                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
2334                          * because we already hold the owner channel lock. */
2335                         ast_queue_hangup(owner);
2336                 }
2337
2338                 if (pvt->peercallno) {
2339                         remove_by_peercallno(pvt);
2340                 }
2341
2342                 if (!owner) {
2343                         ao2_ref(pvt, -1);
2344                         pvt = NULL;
2345                 }
2346         }
2347
2348         if (owner) {
2349                 ast_channel_unlock(owner);
2350         }
2351
2352         if (callno & 0x4000) {
2353                 update_max_trunk();
2354         }
2355 }
2356
2357 static int update_packet(struct iax_frame *f)
2358 {
2359         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2360         struct ast_iax2_full_hdr *fh = f->data;
2361         /* Mark this as a retransmission */
2362         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2363         /* Update iseqno */
2364         f->iseqno = iaxs[f->callno]->iseqno;
2365         fh->iseqno = f->iseqno;
2366         return 0;
2367 }
2368
2369 static int attempt_transmit(const void *data);
2370 static void __attempt_transmit(const void *data)
2371 {
2372         /* Attempt to transmit the frame to the remote peer...
2373            Called without iaxsl held. */
2374         struct iax_frame *f = (struct iax_frame *)data;
2375         int freeme = 0;
2376         int callno = f->callno;
2377         /* Make sure this call is still active */
2378         if (callno) 
2379                 ast_mutex_lock(&iaxsl[callno]);
2380         if (callno && iaxs[callno]) {
2381                 if ((f->retries < 0) /* Already ACK'd */ ||
2382                     (f->retries >= max_retries) /* Too many attempts */) {
2383                                 /* Record an error if we've transmitted too many times */
2384                                 if (f->retries >= max_retries) {
2385                                         if (f->transfer) {
2386                                                 /* Transfer timeout */
2387                                                 struct iax_ie_data ied;
2388                                                 memset(&ied, 0, sizeof(ied));
2389                                                 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, iaxs[callno]->transferid);
2390                                                 if (iaxs[callno]->mediareleased) {
2391                                                         send_command_media(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, ied.buf, ied.pos);
2392                                                 } else {
2393                                                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, ied.buf, ied.pos, -1);
2394                                                 }
2395                                         } else if (f->final) {
2396                                                 if (f->final) 
2397                                                         iax2_destroy(callno);
2398                                         } else {
2399                                                 if (iaxs[callno]->owner)
2400                                                         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);
2401                                                 iaxs[callno]->error = ETIMEDOUT;
2402                                                 if (iaxs[callno]->owner) {
2403                                                         struct ast_frame fr = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
2404                                                         /* Hangup the fd */
2405                                                         iax2_queue_frame(callno, &fr); /* XXX */
2406                                                         /* Remember, owner could disappear */
2407                                                         if (iaxs[callno] && iaxs[callno]->owner)
2408                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2409                                                 } else {
2410                                                         if (iaxs[callno]->reg) {
2411                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2412                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2413                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2414                                                         }
2415                                                         iax2_destroy(callno);
2416                                                 }
2417                                         }
2418
2419                                 }
2420                                 freeme = 1;
2421                 } else {
2422                         /* Update it if it needs it */
2423                         update_packet(f);
2424                         /* Attempt transmission */
2425                         send_packet(f);
2426                         f->retries++;
2427                         /* Try again later after 10 times as long */
2428                         f->retrytime *= 10;
2429                         if (f->retrytime > MAX_RETRY_TIME)
2430                                 f->retrytime = MAX_RETRY_TIME;
2431                         /* Transfer messages max out at one second */
2432                         if (f->transfer && (f->retrytime > 1000))
2433                                 f->retrytime = 1000;
2434                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
2435                 }
2436         } else {
2437                 /* Make sure it gets freed */
2438                 f->retries = -1;
2439                 freeme = 1;
2440         }
2441         if (callno)
2442                 ast_mutex_unlock(&iaxsl[callno]);
2443         /* Do not try again */
2444         if (freeme) {
2445                 /* Don't attempt delivery, just remove it from the queue */
2446                 AST_LIST_LOCK(&frame_queue);
2447                 AST_LIST_REMOVE(&frame_queue, f, list);
2448                 AST_LIST_UNLOCK(&frame_queue);
2449                 f->retrans = -1;
2450                 /* Free the IAX frame */
2451                 iax2_frame_free(f);
2452         }
2453 }
2454
2455 static int attempt_transmit(const void *data)
2456 {
2457 #ifdef SCHED_MULTITHREADED
2458         if (schedule_action(__attempt_transmit, data))
2459 #endif          
2460                 __attempt_transmit(data);
2461         return 0;
2462 }
2463
2464 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2465 {
2466         struct iax2_peer *peer;
2467         static char *choices[] = { "all", NULL };
2468         char *cmplt;
2469
2470         switch (cmd) {
2471         case CLI_INIT:
2472                 e->command = "iax2 prune realtime";
2473                 e->usage =
2474                         "Usage: iax2 prune realtime [<peername>|all]\n"
2475                         "       Prunes object(s) from the cache\n";
2476                 return NULL;
2477         case CLI_GENERATE:
2478                 if (a->pos == 3) {
2479                         cmplt = ast_cli_complete(a->word, choices, a->n);
2480                         if (!cmplt)
2481                                 cmplt = complete_iax2_peers(a->line, a->word, a->pos, a->n - sizeof(choices), IAX_RTCACHEFRIENDS);
2482                         return cmplt;
2483                 }
2484                 return NULL;
2485         }
2486
2487         if (a->argc != 4)
2488                 return CLI_SHOWUSAGE;
2489         if (!strcmp(a->argv[3], "all")) {
2490                 reload_config();
2491                 ast_cli(a->fd, "Cache flushed successfully.\n");
2492         } else if ((peer = find_peer(a->argv[3], 0))) {
2493                 if (ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2494                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2495                         expire_registry(peer_ref(peer));
2496                         ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
2497                 } else {
2498                         ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
2499                 }
2500                 peer_unref(peer);
2501         } else {
2502                 ast_cli(a->fd, "Peer %s was not found in the cache.\n", a->argv[3]);
2503         }
2504         
2505         return CLI_SUCCESS;
2506 }
2507
2508 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2509 {
2510         switch (cmd) {
2511         case CLI_INIT:
2512                 e->command = "iax2 test losspct";
2513                 e->usage =
2514                         "Usage: iax2 test losspct <percentage>\n"
2515                         "       For testing, throws away <percentage> percent of incoming packets\n";
2516                 return NULL;
2517         case CLI_GENERATE:
2518                 return NULL;
2519         }
2520         if (a->argc != 4)
2521                 return CLI_SHOWUSAGE;
2522
2523         test_losspct = atoi(a->argv[3]);
2524
2525         return CLI_SUCCESS;
2526 }
2527
2528 #ifdef IAXTESTS
2529 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2530 {
2531         switch (cmd) {
2532         case CLI_INIT:
2533                 e->command = "iax2 test late";
2534                 e->usage =
2535                         "Usage: iax2 test late <ms>\n"
2536                         "       For testing, count the next frame as <ms> ms late\n";
2537                 return NULL;
2538         case CLI_GENERATE:
2539                 return NULL;
2540         }
2541
2542         if (a->argc != 4)
2543                 return CLI_SHOWUSAGE;
2544
2545         test_late = atoi(a->argv[3]);
2546
2547         return CLI_SUCCESS;
2548 }
2549
2550 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2551 {
2552         switch (cmd) {
2553         case CLI_INIT:
2554                 e->command = "iax2 test resync";
2555                 e->usage =
2556                         "Usage: iax2 test resync <ms>\n"
2557                         "       For testing, adjust all future frames by <ms> ms\n";
2558                 return NULL;
2559         case CLI_GENERATE:
2560                 return NULL;
2561         }
2562
2563         if (a->argc != 4)
2564                 return CLI_SHOWUSAGE;
2565
2566         test_resync = atoi(a->argv[3]);
2567
2568         return CLI_SUCCESS;
2569 }
2570
2571 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2572 {
2573         switch (cmd) {
2574         case CLI_INIT:
2575                 e->command = "iax2 test jitter";
2576                 e->usage =
2577                         "Usage: iax2 test jitter <ms> <pct>\n"
2578                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
2579                         "       percentage of packets. If <pct> is not specified, adds\n"
2580                         "       jitter to all packets.\n";
2581                 return NULL;
2582         case CLI_GENERATE:
2583                 return NULL;
2584         }
2585
2586         if (a->argc < 4 || a->argc > 5)
2587                 return CLI_SHOWUSAGE;
2588
2589         test_jit = atoi(a->argv[3]);
2590         if (a->argc == 5)
2591                 test_jitpct = atoi(a->argv[4]);
2592
2593         return CLI_SUCCESS;
2594 }
2595 #endif /* IAXTESTS */
2596
2597 /*! \brief  peer_status: Report Peer status in character string */
2598 /*      returns 1 if peer is online, -1 if unmonitored */
2599 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2600 {
2601         int res = 0;
2602         if (peer->maxms) {
2603                 if (peer->lastms < 0) {
2604                         ast_copy_string(status, "UNREACHABLE", statuslen);
2605                 } else if (peer->lastms > peer->maxms) {
2606                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2607                         res = 1;
2608                 } else if (peer->lastms) {
2609                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2610                         res = 1;
2611                 } else {
2612                         ast_copy_string(status, "UNKNOWN", statuslen);
2613                 }
2614         } else { 
2615                 ast_copy_string(status, "Unmonitored", statuslen);
2616                 res = -1;
2617         }
2618         return res;
2619 }
2620
2621 /*! \brief Show one peer in detail */
2622 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2623 {
2624         char status[30];
2625         char cbuf[256];
2626         struct iax2_peer *peer;
2627         char codec_buf[512];
2628         int x = 0, codec = 0, load_realtime = 0;
2629
2630         switch (cmd) {
2631         case CLI_INIT:
2632                 e->command = "iax2 show peer";
2633                 e->usage =
2634                         "Usage: iax2 show peer <name>\n"
2635                         "       Display details on specific IAX peer\n";
2636                 return NULL;
2637         case CLI_GENERATE:
2638                 if (a->pos == 3)
2639                         return complete_iax2_peers(a->line, a->word, a->pos, a->n, 0);
2640                 return NULL;
2641         }
2642
2643         if (a->argc < 4)
2644                 return CLI_SHOWUSAGE;
2645
2646         load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
2647
2648         peer = find_peer(a->argv[3], load_realtime);
2649         if (peer) {
2650                 ast_cli(a->fd, "\n\n");
2651                 ast_cli(a->fd, "  * Name       : %s\n", peer->name);
2652                 ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
2653                 ast_cli(a->fd, "  Context      : %s\n", peer->context);
2654                 ast_cli(a->fd, "  Parking lot  : %s\n", peer->parkinglot);
2655                 ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
2656                 ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes" : "No");
2657                 ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2658                 ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
2659                 ast_cli(a->fd, "  ACL          : %s\n", (peer->ha ? "Yes" : "No"));
2660                 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));
2661                 ast_cli(a->fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2662                 ast_cli(a->fd, "  Username     : %s\n", peer->username);
2663                 ast_cli(a->fd, "  Codecs       : ");
2664                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2665                 ast_cli(a->fd, "%s\n", codec_buf);
2666
2667                 ast_cli(a->fd, "  Codec Order  : (");
2668                 for(x = 0; x < 32 ; x++) {
2669                         codec = ast_codec_pref_index(&peer->prefs,x);
2670                         if(!codec)
2671                                 break;
2672                         ast_cli(a->fd, "%s", ast_getformatname(codec));
2673                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2674                                 ast_cli(a->fd, "|");
2675                 }
2676
2677                 if (!x)
2678                         ast_cli(a->fd, "none");
2679                 ast_cli(a->fd, ")\n");
2680
2681                 ast_cli(a->fd, "  Status       : ");
2682                 peer_status(peer, status, sizeof(status));      
2683                 ast_cli(a->fd, "%s\n",status);
2684                 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");
2685                 ast_cli(a->fd, "\n");
2686                 peer_unref(peer);
2687         } else {
2688                 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
2689                 ast_cli(a->fd, "\n");
2690         }
2691
2692         return CLI_SUCCESS;
2693 }
2694
2695 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, int flags)
2696 {
2697         int which = 0;
2698         struct iax2_peer *peer;
2699         char *res = NULL;
2700         int wordlen = strlen(word);
2701         struct ao2_iterator i;
2702
2703         i = ao2_iterator_init(peers, 0);
2704         while ((peer = ao2_iterator_next(&i))) {
2705                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state
2706                         && (!flags || ast_test_flag(peer, flags))) {
2707                         res = ast_strdup(peer->name);
2708                         peer_unref(peer);
2709                         break;
2710                 }
2711                 peer_unref(peer);
2712         }
2713
2714         return res;
2715 }
2716
2717 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2718 {
2719         struct iax_frame *cur;
2720         int cnt = 0, dead = 0, final = 0;
2721
2722         switch (cmd) {
2723         case CLI_INIT:
2724                 e->command = "iax2 show stats";
2725                 e->usage =
2726                         "Usage: iax2 show stats\n"
2727                         "       Display statistics on IAX channel driver.\n";
2728                 return NULL;
2729         case CLI_GENERATE:
2730                 return NULL;
2731         }
2732
2733         if (a->argc != 3)
2734                 return CLI_SHOWUSAGE;
2735
2736         AST_LIST_LOCK(&frame_queue);
2737         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2738                 if (cur->retries < 0)
2739                         dead++;
2740                 if (cur->final)
2741                         final++;
2742                 cnt++;
2743         }
2744         AST_LIST_UNLOCK(&frame_queue);
2745
2746         ast_cli(a->fd, "    IAX Statistics\n");
2747         ast_cli(a->fd, "---------------------\n");
2748         ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2749         ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2750                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2751         ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2752
2753         trunk_timed = trunk_untimed = 0;
2754         if (trunk_maxmtu > trunk_nmaxmtu)
2755                 trunk_nmaxmtu = trunk_maxmtu;
2756
2757         return CLI_SUCCESS;
2758 }
2759
2760 /*! \brief Set trunk MTU from CLI */
2761 static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2762 {
2763         int mtuv;
2764
2765         switch (cmd) {
2766         case CLI_INIT:
2767                 e->command = "iax2 set mtu";
2768                 e->usage =
2769                         "Usage: iax2 set mtu <value>\n"
2770                         "       Set the system-wide IAX IP mtu to <value> bytes net or\n"
2771                         "       zero to disable. Disabling means that the operating system\n"
2772                         "       must handle fragmentation of UDP packets when the IAX2 trunk\n"
2773                         "       packet exceeds the UDP payload size. This is substantially\n"
2774                         "       below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
2775                         "       greater for G.711 samples.\n";
2776                 return NULL;
2777         case CLI_GENERATE:
2778                 return NULL;
2779         }
2780
2781         if (a->argc != 4)
2782                 return CLI_SHOWUSAGE; 
2783         if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
2784                 mtuv = MAX_TRUNK_MTU;
2785         else
2786                 mtuv = atoi(a->argv[3]);
2787
2788         if (mtuv == 0) {
2789                 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2790                 global_max_trunk_mtu = 0; 
2791                 return CLI_SUCCESS; 
2792         }
2793         if (mtuv < 172 || mtuv > 4000) {
2794                 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n"); 
2795                 return CLI_SHOWUSAGE; 
2796         }
2797         ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2798         global_max_trunk_mtu = mtuv; 
2799         return CLI_SUCCESS;
2800 }
2801
2802 static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2803 {
2804         struct iax2_dpcache *dp = NULL;
2805         char tmp[1024], *pc = NULL;
2806         int s, x, y;
2807         struct timeval now = ast_tvnow();
2808
2809         switch (cmd) {
2810         case CLI_INIT:
2811                 e->command = "iax2 show cache";
2812                 e->usage =
2813                         "Usage: iax2 show cache\n"
2814                         "       Display currently cached IAX Dialplan results.\n";
2815                 return NULL;
2816         case CLI_GENERATE:
2817                 return NULL;
2818         }
2819
2820         AST_LIST_LOCK(&dpcache);
2821
2822         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2823
2824         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2825                 s = dp->expiry.tv_sec - now.tv_sec;
2826                 tmp[0] = '\0';
2827                 if (dp->flags & CACHE_FLAG_EXISTS)
2828                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2829                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2830                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2831                 if (dp->flags & CACHE_FLAG_CANEXIST)
2832                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2833                 if (dp->flags & CACHE_FLAG_PENDING)
2834                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2835                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2836                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2837                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2838                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2839                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2840                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2841                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2842                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2843                 /* Trim trailing pipe */
2844                 if (!ast_strlen_zero(tmp)) {
2845                         tmp[strlen(tmp) - 1] = '\0';
2846                 } else {
2847                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2848                 }
2849                 y = 0;
2850                 pc = strchr(dp->peercontext, '@');
2851                 if (!pc) {
2852                         pc = dp->peercontext;
2853                 } else {
2854                         pc++;
2855                 }
2856                 for (x = 0; x < ARRAY_LEN(dp->waiters); x++) {
2857                         if (dp->waiters[x] > -1)
2858                                 y++;
2859                 }
2860                 if (s > 0) {
2861                         ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2862                 } else {
2863                         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2864                 }
2865         }
2866
2867         AST_LIST_LOCK(&dpcache);
2868
2869         return CLI_SUCCESS;
2870 }
2871
2872 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2873
2874 static void unwrap_timestamp(struct iax_frame *fr)
2875 {
2876         /* Video mini frames only encode the lower 15 bits of the session
2877          * timestamp, but other frame types (e.g. audio) encode 16 bits. */
2878         const int ts_shift = (fr->af.frametype == AST_FRAME_VIDEO) ? 15 : 16;
2879         const int lower_mask = (1 << ts_shift) - 1;
2880         const int upper_mask = ~lower_mask;
2881         const int last_upper = iaxs[fr->callno]->last & upper_mask;
2882
2883         if ( (fr->ts & upper_mask) == last_upper ) {
2884                 const int x = fr->ts - iaxs[fr->callno]->last;
2885                 const int threshold = (ts_shift == 15) ? 25000 : 50000;
2886
2887                 if (x < -threshold) {
2888                         /* Sudden big jump backwards in timestamp:
2889                            What likely happened here is that miniframe timestamp has circled but we haven't
2890                            gotten the update from the main packet.  We'll just pretend that we did, and
2891                            update the timestamp appropriately. */
2892                         fr->ts = (last_upper + (1 << ts_shift)) | (fr->ts & lower_mask);
2893                         if (iaxdebug)
2894                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2895                 } else if (x > threshold) {
2896                         /* Sudden apparent big jump forwards in timestamp:
2897                            What's likely happened is this is an old miniframe belonging to the previous
2898                            top 15 or 16-bit timestamp that has turned up out of order.
2899                            Adjust the timestamp appropriately. */
2900                         fr->ts = (last_upper - (1 << ts_shift)) | (fr->ts & lower_mask);
2901                         if (iaxdebug)
2902                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2903                 }
2904         }
2905 }
2906
2907 static int get_from_jb(const void *p);
2908
2909 static void update_jbsched(struct chan_iax2_pvt *pvt)
2910 {
2911         int when;
2912         
2913         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2914         
2915         when = jb_next(pvt->jb) - when;
2916
2917         if (when <= 0) {
2918                 /* XXX should really just empty until when > 0.. */
2919                 when = 1;
2920         }
2921         
2922         pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb, 
2923                 CALLNO_TO_PTR(pvt->callno));
2924 }
2925
2926 static void __get_from_jb(const void *p) 
2927 {
2928         int callno = PTR_TO_CALLNO(p);
2929         struct chan_iax2_pvt *pvt = NULL;
2930         struct iax_frame *fr;
2931         jb_frame frame;
2932         int ret;
2933         long ms;
2934         long next;
2935         struct timeval now = ast_tvnow();
2936         
2937         /* Make sure we have a valid private structure before going on */
2938         ast_mutex_lock(&iaxsl[callno]);
2939         pvt = iaxs[callno];
2940         if (!pvt) {
2941                 /* No go! */
2942                 ast_mutex_unlock(&iaxsl[callno]);
2943                 return;
2944         }
2945
2946         pvt->jbid = -1;
2947         
2948         /* round up a millisecond since ast_sched_runq does; */
2949         /* prevents us from spinning while waiting for our now */
2950         /* to catch up with runq's now */
2951         now.tv_usec += 1000;
2952         
2953         ms = ast_tvdiff_ms(now, pvt->rxcore);
2954         
2955         if(ms >= (next = jb_next(pvt->jb))) {
2956                 ret = jb_get(pvt->jb,&frame,ms,ast_codec_interp_len(pvt->voiceformat));
2957                 switch(ret) {
2958                 case JB_OK:
2959                         fr = frame.data;
2960                         __do_deliver(fr);
2961                         /* __do_deliver() can cause the call to disappear */
2962                         pvt = iaxs[callno];
2963                         break;
2964                 case JB_INTERP:
2965                 {
2966                         struct ast_frame af = { 0, };
2967                         
2968                         /* create an interpolation frame */
2969                         af.frametype = AST_FRAME_VOICE;
2970                         af.subclass = pvt->voiceformat;
2971                         af.samples  = frame.ms * 8;
2972                         af.src  = "IAX2 JB interpolation";
2973                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2974                         af.offset = AST_FRIENDLY_OFFSET;
2975                         
2976                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2977                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2978                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2979                                 iax2_queue_frame(callno, &af);
2980                                 /* iax2_queue_frame() could cause the call to disappear */
2981                                 pvt = iaxs[callno];
2982                         }
2983                 }
2984                         break;
2985                 case JB_DROP:
2986                         iax2_frame_free(frame.data);
2987                         break;
2988                 case JB_NOFRAME:
2989                 case JB_EMPTY:
2990                         /* do nothing */
2991                         break;
2992                 default:
2993                         /* shouldn't happen */
2994                         break;
2995                 }
2996         }
2997         if (pvt)
2998                 update_jbsched(pvt);
2999         ast_mutex_unlock(&iaxsl[callno]);
3000 }
3001
3002 static int get_from_jb(const void *data)
3003 {
3004 #ifdef SCHED_MULTITHREADED
3005         if (schedule_action(__get_from_jb, data))
3006 #endif          
3007                 __get_from_jb(data);
3008         return 0;
3009 }
3010
3011 /*!
3012  * \note This function assumes fr->callno is locked
3013  *
3014  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3015  * was valid before calling it, it may no longer be valid after calling it.
3016  */
3017 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
3018 {
3019         int type, len;
3020         int ret;
3021         int needfree = 0;
3022         struct ast_channel *owner = NULL;
3023         struct ast_channel *bridge = NULL;
3024         
3025         /* Attempt to recover wrapped timestamps */
3026         unwrap_timestamp(fr);
3027
3028         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
3029         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
3030                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
3031         else {
3032 #if 0
3033                 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
3034 #endif
3035                 fr->af.delivery = ast_tv(0,0);
3036         }
3037
3038         type = JB_TYPE_CONTROL;
3039         len = 0;
3040
3041         if(fr->af.frametype == AST_FRAME_VOICE) {
3042                 type = JB_TYPE_VOICE;
3043                 len = ast_codec_get_samples(&fr->af) / 8;
3044         } else if(fr->af.frametype == AST_FRAME_CNG) {
3045                 type = JB_TYPE_SILENCE;
3046         }
3047
3048         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
3049                 if (tsout)
3050                         *tsout = fr->ts;
3051                 __do_deliver(fr);
3052                 return -1;
3053         }
3054
3055         if ((owner = iaxs[fr->callno]->owner))
3056                 bridge = ast_bridged_channel(owner);
3057
3058         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
3059          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
3060         if ( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) && owner && bridge && (bridge->tech->properties & AST_CHAN_TP_WANTSJITTER) ) {
3061                 jb_frame frame;
3062
3063                 /* deliver any frames in the jb */
3064                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
3065                         __do_deliver(frame.data);
3066                         /* __do_deliver() can make the call disappear */
3067                         if (!iaxs[fr->callno])
3068                                 return -1;
3069                 }
3070
3071                 jb_reset(iaxs[fr->callno]->jb);
3072
3073                 AST_SCHED_DEL(sched, iaxs[fr->callno]->jbid);
3074
3075                 /* deliver this frame now */
3076                 if (tsout)
3077                         *tsout = fr->ts;
3078                 __do_deliver(fr);
3079                 return -1;
3080         }
3081
3082         /* insert into jitterbuffer */
3083         /* TODO: Perhaps we could act immediately if it's not droppable and late */
3084         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
3085                         calc_rxstamp(iaxs[fr->callno],fr->ts));
3086         if (ret == JB_DROP) {
3087                 needfree++;
3088         } else if (ret == JB_SCHED) {
3089                 update_jbsched(iaxs[fr->callno]);
3090         }
3091         if (tsout)
3092                 *tsout = fr->ts;
3093         if (needfree) {
3094                 /* Free our iax frame */
3095                 iax2_frame_free(fr);
3096                 return -1;
3097         }
3098         return 0;
3099 }
3100
3101 static int iax2_transmit(struct iax_frame *fr)
3102 {
3103         /* Lock the queue and place this packet at the end */
3104         /* By setting this to 0, the network thread will send it for us, and
3105            queue retransmission if necessary */
3106         fr->sentyet = 0;
3107         AST_LIST_LOCK(&frame_queue);
3108         AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
3109         AST_LIST_UNLOCK(&frame_queue);
3110         /* Wake up the network and scheduler thread */
3111         if (netthreadid != AST_PTHREADT_NULL)
3112                 pthread_kill(netthreadid, SIGURG);
3113         signal_condition(&sched_lock, &sched_cond);
3114         return 0;
3115 }
3116
3117
3118
3119 static int iax2_digit_begin(struct ast_channel *c, char digit)
3120 {
3121         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
3122 }
3123
3124 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
3125 {
3126         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
3127 }
3128
3129 static int iax2_sendtext(struct ast_channel *c, const char *text)
3130 {
3131         
3132         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
3133                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
3134 }
3135
3136 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
3137 {
3138         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data.ptr, img->datalen, -1);
3139 }
3140
3141 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
3142 {
3143         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
3144 }
3145
3146 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
3147 {
3148         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
3149         ast_mutex_lock(&iaxsl[callno]);
3150         if (iaxs[callno])
3151                 iaxs[callno]->owner = newchan;
3152         else
3153                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
3154         ast_mutex_unlock(&iaxsl[callno]);
3155         return 0;
3156 }
3157
3158 /*!
3159  * \note This function calls reg_source_db -> iax2_poke_peer -> find_callno,
3160  *       so do not call this with a pvt lock held.
3161  */
3162 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
3163 {
3164         struct ast_variable *var = NULL;
3165         struct ast_variable *tmp;
3166         struct iax2_peer *peer=NULL;
3167         time_t regseconds = 0, nowtime;
3168         int dynamic=0;
3169
3170         if (peername) {
3171                 var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", SENTINEL);
3172                 if (!var && sin)
3173                         var = ast_load_realtime("iaxpeers", "name", peername, "host", ast_inet_ntoa(sin->sin_addr), SENTINEL);
3174         } else if (sin) {
3175                 char porta[25];
3176                 sprintf(porta, "%d", ntohs(sin->sin_port));
3177                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, SENTINEL);
3178                 if (var) {
3179                         /* We'll need the peer name in order to build the structure! */
3180                         for (tmp = var; tmp; tmp = tmp->next) {
3181                                 if (!strcasecmp(tmp->name, "name"))
3182                                         peername = tmp->value;
3183                         }
3184                 }
3185         }
3186         if (!var && peername) { /* Last ditch effort */
3187                 var = ast_load_realtime("iaxpeers", "name", peername, SENTINEL);
3188                 /*!\note
3189  &nbs