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