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