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