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