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