Merged revisions 48502 via svnmerge from
[asterisk/asterisk.git] / channels / chan_iax2.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Implementation of Inter-Asterisk eXchange Version 2
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \par See also
26  * \arg \ref Config_iax
27  *
28  * \ingroup channel_drivers
29  */
30
31 /*** MODULEINFO
32         <use>zaptel</use>
33  ***/
34
35 #include "asterisk.h"
36
37 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
38
39 #include <stdlib.h>
40 #include <stdio.h>
41 #include <sys/types.h>
42 #include <sys/mman.h>
43 #include <dirent.h>
44 #include <sys/socket.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
47 #include <netinet/in_systm.h>
48 #include <netinet/ip.h>
49 #include <sys/time.h>
50 #include <sys/signal.h>
51 #include <signal.h>
52 #include <string.h>
53 #include <strings.h>
54 #include <errno.h>
55 #include <unistd.h>
56 #include <netdb.h>
57 #include <fcntl.h>
58 #include <sys/stat.h>
59 #include <regex.h>
60
61 #ifdef HAVE_ZAPTEL
62 #include <sys/ioctl.h>
63 #include <zaptel/zaptel.h>
64 #endif
65
66 #include "asterisk/lock.h"
67 #include "asterisk/frame.h" 
68 #include "asterisk/channel.h"
69 #include "asterisk/logger.h"
70 #include "asterisk/module.h"
71 #include "asterisk/pbx.h"
72 #include "asterisk/sched.h"
73 #include "asterisk/io.h"
74 #include "asterisk/config.h"
75 #include "asterisk/options.h"
76 #include "asterisk/cli.h"
77 #include "asterisk/translate.h"
78 #include "asterisk/md5.h"
79 #include "asterisk/cdr.h"
80 #include "asterisk/crypto.h"
81 #include "asterisk/acl.h"
82 #include "asterisk/manager.h"
83 #include "asterisk/callerid.h"
84 #include "asterisk/app.h"
85 #include "asterisk/astdb.h"
86 #include "asterisk/musiconhold.h"
87 #include "asterisk/features.h"
88 #include "asterisk/utils.h"
89 #include "asterisk/causes.h"
90 #include "asterisk/localtime.h"
91 #include "asterisk/aes.h"
92 #include "asterisk/dnsmgr.h"
93 #include "asterisk/devicestate.h"
94 #include "asterisk/netsock.h"
95 #include "asterisk/stringfields.h"
96 #include "asterisk/linkedlists.h"
97
98 #include "iax2.h"
99 #include "iax2-parser.h"
100 #include "iax2-provision.h"
101 #include "jitterbuf.h"
102
103 /* Define SCHED_MULTITHREADED to run the scheduler in a special
104    multithreaded mode. */
105 #define SCHED_MULTITHREADED
106
107 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
108    thread is actually doing. */
109 #define DEBUG_SCHED_MULTITHREAD
110
111 #ifndef IPTOS_MINCOST
112 #define IPTOS_MINCOST 0x02
113 #endif
114
115 #ifdef SO_NO_CHECK
116 static int nochecksums = 0;
117 #endif
118
119
120 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
121 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
122
123 #define DEFAULT_THREAD_COUNT 10
124 #define DEFAULT_MAX_THREAD_COUNT 100
125 #define DEFAULT_RETRY_TIME 1000
126 #define MEMORY_SIZE 100
127 #define DEFAULT_DROP 3
128 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
129    but keeps the division between trunked and non-trunked better. */
130 #define TRUNK_CALL_START        0x4000
131
132 #define DEBUG_SUPPORT
133
134 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
135
136 /* Sample over last 100 units to determine historic jitter */
137 #define GAMMA (0.01)
138
139 static struct ast_codec_pref prefs;
140
141 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
142
143
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 struct iax2_thread *find_idle_thread(void)
875 {
876         struct iax2_thread *thread = NULL;
877
878         /* Pop the head of the list off */
879         AST_LIST_LOCK(&idle_list);
880         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
881         AST_LIST_UNLOCK(&idle_list);
882
883         /* If no idle thread is available from the regular list, try dynamic */
884         if (thread == NULL) {
885                 AST_LIST_LOCK(&dynamic_list);
886                 thread = AST_LIST_FIRST(&dynamic_list);
887                 if (thread != NULL) {
888                         AST_LIST_REMOVE(&dynamic_list, thread, list);
889                 }
890                 /* Make sure we absolutely have a thread... if not, try to make one if allowed */
891                 if (thread == NULL && iaxmaxthreadcount > iaxdynamicthreadcount) {
892                         /* We need to MAKE a thread! */
893                         thread = ast_calloc(1, sizeof(*thread));
894                         if (thread != NULL) {
895                                 thread->threadnum = iaxdynamicthreadcount;
896                                 thread->type = IAX_THREAD_TYPE_DYNAMIC;
897                                 ast_mutex_init(&thread->lock);
898                                 ast_cond_init(&thread->cond, NULL);
899                                 if (ast_pthread_create(&thread->threadid, NULL, iax2_process_thread, thread)) {
900                                         free(thread);
901                                         thread = NULL;
902                                 } else {
903                                         /* All went well and the thread is up, so increment our count */
904                                         iaxdynamicthreadcount++;
905                                 }
906                         }
907                 }
908                 AST_LIST_UNLOCK(&dynamic_list);
909         }
910
911         return thread;
912 }
913
914 #ifdef SCHED_MULTITHREADED
915 static int __schedule_action(void (*func)(void *data), void *data, const char *funcname)
916 {
917         struct iax2_thread *thread = NULL;
918         static time_t lasterror;
919         static time_t t;
920
921         thread = find_idle_thread();
922
923         if (thread != NULL) {
924                 thread->schedfunc = func;
925                 thread->scheddata = data;
926                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
927 #ifdef DEBUG_SCHED_MULTITHREAD
928                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
929 #endif
930                 signal_condition(&thread->lock, &thread->cond);
931                 return 0;
932         }
933         time(&t);
934         if (t != lasterror) 
935                 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
936         lasterror = t;
937
938         return -1;
939 }
940 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
941 #endif
942
943 static void __send_ping(void *data)
944 {
945         int callno = (long)data;
946         send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
947 }
948
949 static int send_ping(void *data)
950 {
951         int callno = (long)data;
952         if (iaxs[callno]) {
953 #ifdef SCHED_MULTITHREADED
954                 if (schedule_action(__send_ping, data))
955 #endif          
956                         __send_ping(data);
957                 return 1;
958         } else
959                 return 0;
960         return 0;
961 }
962
963 static int get_encrypt_methods(const char *s)
964 {
965         int e;
966         if (!strcasecmp(s, "aes128"))
967                 e = IAX_ENCRYPT_AES128;
968         else if (ast_true(s))
969                 e = IAX_ENCRYPT_AES128;
970         else
971                 e = 0;
972         return e;
973 }
974
975 static void __send_lagrq(void *data)
976 {
977         int callno = (long)data;
978         /* Ping only if it's real not if it's bridged */
979         send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
980 }
981
982 static int send_lagrq(void *data)
983 {
984         int callno = (long)data;
985         if (iaxs[callno]) {
986 #ifdef SCHED_MULTITHREADED
987                 if (schedule_action(__send_lagrq, data))
988 #endif          
989                         __send_lagrq(data);
990                 return 1;
991         } else
992                 return 0;
993         return 0;
994 }
995
996 static unsigned char compress_subclass(int subclass)
997 {
998         int x;
999         int power=-1;
1000         /* If it's 128 or smaller, just return it */
1001         if (subclass < IAX_FLAG_SC_LOG)
1002                 return subclass;
1003         /* Otherwise find its power */
1004         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1005                 if (subclass & (1 << x)) {
1006                         if (power > -1) {
1007                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1008                                 return 0;
1009                         } else
1010                                 power = x;
1011                 }
1012         }
1013         return power | IAX_FLAG_SC_LOG;
1014 }
1015
1016 static int uncompress_subclass(unsigned char csub)
1017 {
1018         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1019         if (csub & IAX_FLAG_SC_LOG) {
1020                 /* special case for 'compressed' -1 */
1021                 if (csub == 0xff)
1022                         return -1;
1023                 else
1024                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1025         }
1026         else
1027                 return csub;
1028 }
1029
1030 static struct iax2_peer *find_peer(const char *name, int realtime) 
1031 {
1032         struct iax2_peer *peer = NULL;
1033
1034         /* Grab peer from linked list */
1035         AST_LIST_LOCK(&peers);
1036         AST_LIST_TRAVERSE(&peers, peer, entry) {
1037                 if (!strcasecmp(peer->name, name)) {
1038                         break;
1039                 }
1040         }
1041         AST_LIST_UNLOCK(&peers);
1042
1043         /* Now go for realtime if applicable */
1044         if(!peer && realtime)
1045                 peer = realtime_peer(name, NULL);
1046         return peer;
1047 }
1048
1049 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1050 {
1051         struct iax2_peer *peer = NULL;
1052         int res = 0;
1053
1054         if (lockpeer)
1055                 AST_LIST_LOCK(&peers);
1056         AST_LIST_TRAVERSE(&peers, peer, entry) {
1057                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1058                     (peer->addr.sin_port == sin.sin_port)) {
1059                         ast_copy_string(host, peer->name, len);
1060                         res = 1;
1061                         break;
1062                 }
1063         }
1064         if (lockpeer)
1065                 AST_LIST_UNLOCK(&peers);
1066         if (!peer) {
1067                 peer = realtime_peer(NULL, &sin);
1068                 if (peer) {
1069                         ast_copy_string(host, peer->name, len);
1070                         if (ast_test_flag(peer, IAX_TEMPONLY))
1071                                 destroy_peer(peer);
1072                         res = 1;
1073                 }
1074         }
1075
1076         return res;
1077 }
1078
1079 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1080 {
1081         struct chan_iax2_pvt *tmp;
1082         jb_conf jbconf;
1083
1084         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1085                 return NULL;
1086
1087         if (ast_string_field_init(tmp, 32)) {
1088                 free(tmp);
1089                 tmp = NULL;
1090                 return NULL;
1091         }
1092                 
1093         tmp->prefs = prefs;
1094         tmp->pingid = -1;
1095         tmp->lagid = -1;
1096         tmp->autoid = -1;
1097         tmp->authid = -1;
1098         tmp->initid = -1;
1099
1100         ast_string_field_set(tmp,exten, "s");
1101         ast_string_field_set(tmp,host, host);
1102
1103         tmp->jb = jb_new();
1104         tmp->jbid = -1;
1105         jbconf.max_jitterbuf = maxjitterbuffer;
1106         jbconf.resync_threshold = resyncthreshold;
1107         jbconf.max_contig_interp = maxjitterinterps;
1108         jb_setconf(tmp->jb,&jbconf);
1109
1110         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1111
1112         return tmp;
1113 }
1114
1115 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1116 {
1117         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen);
1118         if (new) {
1119                 size_t mallocd_datalen = new->mallocd_datalen;
1120                 memcpy(new, fr, sizeof(*new));
1121                 iax_frame_wrap(new, &fr->af);
1122                 new->mallocd_datalen = mallocd_datalen;
1123                 new->data = NULL;
1124                 new->datalen = 0;
1125                 new->direction = DIRECTION_INGRESS;
1126                 new->retrans = -1;
1127         }
1128         return new;
1129 }
1130
1131 #define NEW_PREVENT     0
1132 #define NEW_ALLOW       1
1133 #define NEW_FORCE       2
1134
1135 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, struct chan_iax2_pvt *cur)
1136 {
1137         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1138                 (cur->addr.sin_port == sin->sin_port)) {
1139                 /* This is the main host */
1140                 if ((cur->peercallno == callno) ||
1141                         ((dcallno == cur->callno) && !cur->peercallno)) {
1142                         /* That's us.  Be sure we keep track of the peer call number */
1143                         return 1;
1144                 }
1145         }
1146         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1147             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1148                 /* We're transferring */
1149                 if (dcallno == cur->callno)
1150                         return 1;
1151         }
1152         return 0;
1153 }
1154
1155 static void update_max_trunk(void)
1156 {
1157         int max = TRUNK_CALL_START;
1158         int x;
1159         /* XXX Prolly don't need locks here XXX */
1160         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1161                 if (iaxs[x])
1162                         max = x + 1;
1163         }
1164         maxtrunkcall = max;
1165         if (option_debug && iaxdebug)
1166                 ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max);
1167 }
1168
1169 static void update_max_nontrunk(void)
1170 {
1171         int max = 1;
1172         int x;
1173         /* XXX Prolly don't need locks here XXX */
1174         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1175                 if (iaxs[x])
1176                         max = x + 1;
1177         }
1178         maxnontrunkcall = max;
1179         if (option_debug && iaxdebug)
1180                 ast_log(LOG_DEBUG, "New max nontrunk callno is %d\n", max);
1181 }
1182
1183 static int make_trunk(unsigned short callno, int locked)
1184 {
1185         int x;
1186         int res= 0;
1187         struct timeval now;
1188         if (iaxs[callno]->oseqno) {
1189                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1190                 return -1;
1191         }
1192         if (callno & TRUNK_CALL_START) {
1193                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1194                 return -1;
1195         }
1196         gettimeofday(&now, NULL);
1197         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1198                 ast_mutex_lock(&iaxsl[x]);
1199                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1200                         iaxs[x] = iaxs[callno];
1201                         iaxs[x]->callno = x;
1202                         iaxs[callno] = NULL;
1203                         /* Update the two timers that should have been started */
1204                         if (iaxs[x]->pingid > -1)
1205                                 ast_sched_del(sched, iaxs[x]->pingid);
1206                         if (iaxs[x]->lagid > -1)
1207                                 ast_sched_del(sched, iaxs[x]->lagid);
1208                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1209                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1210                         if (locked)
1211                                 ast_mutex_unlock(&iaxsl[callno]);
1212                         res = x;
1213                         if (!locked)
1214                                 ast_mutex_unlock(&iaxsl[x]);
1215                         break;
1216                 }
1217                 ast_mutex_unlock(&iaxsl[x]);
1218         }
1219         if (x >= IAX_MAX_CALLS - 1) {
1220                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1221                 return -1;
1222         }
1223         if (option_debug)
1224                 ast_log(LOG_DEBUG, "Made call %d into trunk call %d\n", callno, x);
1225         /* We move this call from a non-trunked to a trunked call */
1226         update_max_trunk();
1227         update_max_nontrunk();
1228         return res;
1229 }
1230
1231 /*!
1232  * \todo XXX Note that this function contains a very expensive operation that
1233  * happens for *every* incoming media frame.  It iterates through every
1234  * possible call number, locking and unlocking each one, to try to match the
1235  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1236  * So, for an call with a local call number of 20000, every incoming audio
1237  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1238  *
1239  * It's a shame that IAX2 media frames carry the source call number instead of
1240  * the destination call number.  If they did, this lookup wouldn't be needed.
1241  * However, it's too late to change that now.  Instead, we need to come up with
1242  * a better way of indexing active calls so that these frequent lookups are not
1243  * so expensive.
1244  */
1245 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1246 {
1247         int res = 0;
1248         int x;
1249         struct timeval now;
1250         char host[80];
1251         if (new <= NEW_ALLOW) {
1252                 /* Look for an existing connection first */
1253                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1254                         ast_mutex_lock(&iaxsl[x]);
1255                         if (iaxs[x]) {
1256                                 /* Look for an exact match */
1257                                 if (match(sin, callno, dcallno, iaxs[x])) {
1258                                         res = x;
1259                                 }
1260                         }
1261                         ast_mutex_unlock(&iaxsl[x]);
1262                 }
1263                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1264                         ast_mutex_lock(&iaxsl[x]);
1265                         if (iaxs[x]) {
1266                                 /* Look for an exact match */
1267                                 if (match(sin, callno, dcallno, iaxs[x])) {
1268                                         res = x;
1269                                 }
1270                         }
1271                         ast_mutex_unlock(&iaxsl[x]);
1272                 }
1273         }
1274         if ((res < 1) && (new >= NEW_ALLOW)) {
1275                 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1276                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1277                 gettimeofday(&now, NULL);
1278                 for (x=1;x<TRUNK_CALL_START;x++) {
1279                         /* Find first unused call number that hasn't been used in a while */
1280                         ast_mutex_lock(&iaxsl[x]);
1281                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1282                         ast_mutex_unlock(&iaxsl[x]);
1283                 }
1284                 /* We've still got lock held if we found a spot */
1285                 if (x >= TRUNK_CALL_START) {
1286                         ast_log(LOG_WARNING, "No more space\n");
1287                         return 0;
1288                 }
1289                 iaxs[x] = new_iax(sin, lockpeer, host);
1290                 update_max_nontrunk();
1291                 if (iaxs[x]) {
1292                         if (option_debug && iaxdebug)
1293                                 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
1294                         iaxs[x]->sockfd = sockfd;
1295                         iaxs[x]->addr.sin_port = sin->sin_port;
1296                         iaxs[x]->addr.sin_family = sin->sin_family;
1297                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1298                         iaxs[x]->peercallno = callno;
1299                         iaxs[x]->callno = x;
1300                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1301                         iaxs[x]->expiry = min_reg_expire;
1302                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1303                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1304                         iaxs[x]->amaflags = amaflags;
1305                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1306                         
1307                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1308                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1309                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1310                 } else {
1311                         ast_log(LOG_WARNING, "Out of resources\n");
1312                         ast_mutex_unlock(&iaxsl[x]);
1313                         return 0;
1314                 }
1315                 ast_mutex_unlock(&iaxsl[x]);
1316                 res = x;
1317         }
1318         return res;
1319 }
1320
1321 static void iax2_frame_free(struct iax_frame *fr)
1322 {
1323         if (fr->retrans > -1)
1324                 ast_sched_del(sched, fr->retrans);
1325         iax_frame_free(fr);
1326 }
1327
1328 static int iax2_queue_frame(int callno, struct ast_frame *f)
1329 {
1330         /* Assumes lock for callno is already held... */
1331         for (;;) {
1332                 if (iaxs[callno] && iaxs[callno]->owner) {
1333                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1334                                 /* Avoid deadlock by pausing and trying again */
1335                                 ast_mutex_unlock(&iaxsl[callno]);
1336                                 usleep(1);
1337                                 ast_mutex_lock(&iaxsl[callno]);
1338                         } else {
1339                                 ast_queue_frame(iaxs[callno]->owner, f);
1340                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1341                                 break;
1342                         }
1343                 } else
1344                         break;
1345         }
1346         return 0;
1347 }
1348
1349 static void destroy_firmware(struct iax_firmware *cur)
1350 {
1351         /* Close firmware */
1352         if (cur->fwh) {
1353                 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1354         }
1355         close(cur->fd);
1356         free(cur);
1357 }
1358
1359 static int try_firmware(char *s)
1360 {
1361         struct stat stbuf;
1362         struct iax_firmware *cur = NULL;
1363         int ifd, fd, res, len, chunk;
1364         struct ast_iax2_firmware_header *fwh, fwh2;
1365         struct MD5Context md5;
1366         unsigned char sum[16], buf[1024];
1367         char *s2, *last;
1368
1369         if (!(s2 = alloca(strlen(s) + 100))) {
1370                 ast_log(LOG_WARNING, "Alloca failed!\n");
1371                 return -1;
1372         }
1373
1374         last = strrchr(s, '/');
1375         if (last)
1376                 last++;
1377         else
1378                 last = s;
1379
1380         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1381
1382         if ((res = stat(s, &stbuf) < 0)) {
1383                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1384                 return -1;
1385         }
1386
1387         /* Make sure it's not a directory */
1388         if (S_ISDIR(stbuf.st_mode))
1389                 return -1;
1390         ifd = open(s, O_RDONLY);
1391         if (ifd < 0) {
1392                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1393                 return -1;
1394         }
1395         fd = open(s2, O_RDWR | O_CREAT | O_EXCL);
1396         if (fd < 0) {
1397                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1398                 close(ifd);
1399                 return -1;
1400         }
1401         /* Unlink our newly created file */
1402         unlink(s2);
1403         
1404         /* Now copy the firmware into it */
1405         len = stbuf.st_size;
1406         while(len) {
1407                 chunk = len;
1408                 if (chunk > sizeof(buf))
1409                         chunk = sizeof(buf);
1410                 res = read(ifd, buf, chunk);
1411                 if (res != chunk) {
1412                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1413                         close(ifd);
1414                         close(fd);
1415                         return -1;
1416                 }
1417                 res = write(fd, buf, chunk);
1418                 if (res != chunk) {
1419                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1420                         close(ifd);
1421                         close(fd);
1422                         return -1;
1423                 }
1424                 len -= chunk;
1425         }
1426         close(ifd);
1427         /* Return to the beginning */
1428         lseek(fd, 0, SEEK_SET);
1429         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1430                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1431                 close(fd);
1432                 return -1;
1433         }
1434         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1435                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1436                 close(fd);
1437                 return -1;
1438         }
1439         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1440                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1441                 close(fd);
1442                 return -1;
1443         }
1444         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1445                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1446                 close(fd);
1447                 return -1;
1448         }
1449         fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1450         if (!fwh) {
1451                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1452                 close(fd);
1453                 return -1;
1454         }
1455         MD5Init(&md5);
1456         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1457         MD5Final(sum, &md5);
1458         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1459                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1460                 munmap(fwh, stbuf.st_size);
1461                 close(fd);
1462                 return -1;
1463         }
1464
1465         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1466                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1467                         /* Found a candidate */
1468                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1469                                 /* The version we have on loaded is older, load this one instead */
1470                                 break;
1471                         /* This version is no newer than what we have.  Don't worry about it.
1472                            We'll consider it a proper load anyhow though */
1473                         munmap(fwh, stbuf.st_size);
1474                         close(fd);
1475                         return 0;
1476                 }
1477         }
1478         
1479         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1480                 cur->fd = -1;
1481                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1482         }
1483         
1484         if (cur) {
1485                 if (cur->fwh)
1486                         munmap(cur->fwh, cur->mmaplen);
1487                 if (cur->fd > -1)
1488                         close(cur->fd);
1489                 cur->fwh = fwh;
1490                 cur->fd = fd;
1491                 cur->mmaplen = stbuf.st_size;
1492                 cur->dead = 0;
1493         }
1494         
1495         return 0;
1496 }
1497
1498 static int iax_check_version(char *dev)
1499 {
1500         int res = 0;
1501         struct iax_firmware *cur = NULL;
1502
1503         if (ast_strlen_zero(dev))
1504                 return 0;
1505
1506         AST_LIST_LOCK(&firmwares);
1507         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1508                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1509                         res = ntohs(cur->fwh->version);
1510                         break;
1511                 }
1512         }
1513         AST_LIST_UNLOCK(&firmwares);
1514
1515         return res;
1516 }
1517
1518 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1519 {
1520         int res = -1;
1521         unsigned int bs = desc & 0xff;
1522         unsigned int start = (desc >> 8) & 0xffffff;
1523         unsigned int bytes;
1524         struct iax_firmware *cur;
1525
1526         if (ast_strlen_zero((char *)dev) || !bs)
1527                 return -1;
1528
1529         start *= bs;
1530         
1531         AST_LIST_LOCK(&firmwares);
1532         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1533                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1534                         continue;
1535                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1536                 if (start < ntohl(cur->fwh->datalen)) {
1537                         bytes = ntohl(cur->fwh->datalen) - start;
1538                         if (bytes > bs)
1539                                 bytes = bs;
1540                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1541                 } else {
1542                         bytes = 0;
1543                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1544                 }
1545                 if (bytes == bs)
1546                         res = 0;
1547                 else
1548                         res = 1;
1549                 break;
1550         }
1551         AST_LIST_UNLOCK(&firmwares);
1552
1553         return res;
1554 }
1555
1556
1557 static void reload_firmware(void)
1558 {
1559         struct iax_firmware *cur = NULL;
1560         DIR *fwd;
1561         struct dirent *de;
1562         char dir[256], fn[256];
1563
1564         AST_LIST_LOCK(&firmwares);
1565
1566         /* Mark all as dead */
1567         AST_LIST_TRAVERSE(&firmwares, cur, list)
1568                 cur->dead = 1;
1569
1570         /* Now that we have marked them dead... load new ones */
1571         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1572         fwd = opendir(dir);
1573         if (fwd) {
1574                 while((de = readdir(fwd))) {
1575                         if (de->d_name[0] != '.') {
1576                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1577                                 if (!try_firmware(fn)) {
1578                                         if (option_verbose > 1)
1579                                                 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1580                                 }
1581                         }
1582                 }
1583                 closedir(fwd);
1584         } else 
1585                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1586
1587         /* Clean up leftovers */
1588         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1589                 if (!cur->dead)
1590                         continue;
1591                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1592                 destroy_firmware(cur);
1593         }
1594         AST_LIST_TRAVERSE_SAFE_END
1595
1596         AST_LIST_UNLOCK(&firmwares);
1597 }
1598
1599 static int __do_deliver(void *data)
1600 {
1601         /* Just deliver the packet by using queueing.  This is called by
1602           the IAX thread with the iaxsl lock held. */
1603         struct iax_frame *fr = data;
1604         fr->retrans = -1;
1605         fr->af.has_timing_info = 0;
1606         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1607                 iax2_queue_frame(fr->callno, &fr->af);
1608         /* Free our iax frame */
1609         iax2_frame_free(fr);
1610         /* And don't run again */
1611         return 0;
1612 }
1613
1614 static int handle_error(void)
1615 {
1616         /* XXX Ideally we should figure out why an error occurred and then abort those
1617            rather than continuing to try.  Unfortunately, the published interface does
1618            not seem to work XXX */
1619 #if 0
1620         struct sockaddr_in *sin;
1621         int res;
1622         struct msghdr m;
1623         struct sock_extended_err e;
1624         m.msg_name = NULL;
1625         m.msg_namelen = 0;
1626         m.msg_iov = NULL;
1627         m.msg_control = &e;
1628         m.msg_controllen = sizeof(e);
1629         m.msg_flags = 0;
1630         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1631         if (res < 0)
1632                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1633         else {
1634                 if (m.msg_controllen) {
1635                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1636                         if (sin) 
1637                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1638                         else
1639                                 ast_log(LOG_WARNING, "No address detected??\n");
1640                 } else {
1641                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1642                 }
1643         }
1644 #endif
1645         return 0;
1646 }
1647
1648 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1649 {
1650         int res;
1651         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1652                                         sizeof(*sin));
1653         if (res < 0) {
1654                 if (option_debug)
1655                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1656                 handle_error();
1657         } else
1658                 res = 0;
1659         return res;
1660 }
1661
1662 static int send_packet(struct iax_frame *f)
1663 {
1664         int res;
1665         int callno = f->callno;
1666
1667         /* Don't send if there was an error, but return error instead */
1668         if (!callno || !iaxs[callno] || iaxs[callno]->error)
1669             return -1;
1670         
1671         /* Called with iaxsl held */
1672         if (option_debug > 2 && iaxdebug)
1673                 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));
1674         if (f->transfer) {
1675                 if (iaxdebug)
1676                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1677                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1678                                         sizeof(iaxs[callno]->transfer));
1679         } else {
1680                 if (iaxdebug)
1681                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1682                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1683                                         sizeof(iaxs[callno]->addr));
1684         }
1685         if (res < 0) {
1686                 if (option_debug && iaxdebug)
1687                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1688                 handle_error();
1689         } else
1690                 res = 0;
1691         return res;
1692 }
1693
1694 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1695 {
1696         struct iax2_user *user = NULL;
1697
1698         /* Decrement AUTHREQ count if needed */
1699         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1700                 AST_LIST_LOCK(&users);
1701                 AST_LIST_TRAVERSE(&users, user, entry) {
1702                         if (!strcmp(user->name, pvt->username)) {
1703                                 user->curauthreq--;
1704                                 break;
1705                         }
1706                 }
1707                 AST_LIST_UNLOCK(&users);
1708                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1709         }
1710         /* No more pings or lagrq's */
1711         if (pvt->pingid > -1)
1712                 ast_sched_del(sched, pvt->pingid);
1713         pvt->pingid = -1;
1714         if (pvt->lagid > -1)
1715                 ast_sched_del(sched, pvt->lagid);
1716         pvt->lagid = -1;
1717         if (pvt->autoid > -1)
1718                 ast_sched_del(sched, pvt->autoid);
1719         pvt->autoid = -1;
1720         if (pvt->authid > -1)
1721                 ast_sched_del(sched, pvt->authid);
1722         pvt->authid = -1;
1723         if (pvt->initid > -1)
1724                 ast_sched_del(sched, pvt->initid);
1725         pvt->initid = -1;
1726         if (pvt->jbid > -1)
1727                 ast_sched_del(sched, pvt->jbid);
1728         pvt->jbid = -1;
1729 }
1730
1731 static int iax2_predestroy(int callno)
1732 {
1733         struct ast_channel *c = NULL;
1734         struct chan_iax2_pvt *pvt = iaxs[callno];
1735
1736         if (!pvt)
1737                 return -1;
1738
1739         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1740                 iax2_destroy_helper(pvt);
1741                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1742         }
1743
1744         if ((c = pvt->owner)) {
1745                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1746                 c->tech_pvt = NULL;
1747                 ast_queue_hangup(c);
1748                 pvt->owner = NULL;
1749         }
1750
1751         return 0;
1752 }
1753
1754 static void iax2_destroy(int callno)
1755 {
1756         struct chan_iax2_pvt *pvt = NULL;
1757         struct iax_frame *cur = NULL;
1758         struct ast_channel *owner = NULL;
1759
1760 retry:
1761         pvt = iaxs[callno];
1762         gettimeofday(&lastused[callno], NULL);
1763         
1764         owner = pvt ? pvt->owner : NULL;
1765
1766         if (owner) {
1767                 if (ast_mutex_trylock(&owner->lock)) {
1768                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1769                         ast_mutex_unlock(&iaxsl[callno]);
1770                         usleep(1);
1771                         ast_mutex_lock(&iaxsl[callno]);
1772                         goto retry;
1773                 }
1774         }
1775         if (!owner)
1776                 iaxs[callno] = NULL;
1777         if (pvt) {
1778                 if (!owner)
1779                         pvt->owner = NULL;
1780                 iax2_destroy_helper(pvt);
1781
1782                 /* Already gone */
1783                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1784
1785                 if (owner) {
1786                         /* If there's an owner, prod it to give up */
1787                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1788                         ast_queue_hangup(owner);
1789                 }
1790
1791                 AST_LIST_LOCK(&iaxq.queue);
1792                 AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
1793                         /* Cancel any pending transmissions */
1794                         if (cur->callno == pvt->callno) 
1795                                 cur->retries = -1;
1796                 }
1797                 AST_LIST_UNLOCK(&iaxq.queue);
1798
1799                 if (pvt->reg)
1800                         pvt->reg->callno = 0;
1801                 if (!owner) {
1802                         jb_frame frame;
1803                         if (pvt->vars) {
1804                             ast_variables_destroy(pvt->vars);
1805                             pvt->vars = NULL;
1806                         }
1807
1808                         while (jb_getall(pvt->jb, &frame) == JB_OK)
1809                                 iax2_frame_free(frame.data);
1810                         jb_destroy(pvt->jb);
1811                         /* gotta free up the stringfields */
1812                         ast_string_field_free_pools(pvt);
1813                         free(pvt);
1814                 }
1815         }
1816         if (owner) {
1817                 ast_mutex_unlock(&owner->lock);
1818         }
1819         if (callno & 0x4000)
1820                 update_max_trunk();
1821 }
1822
1823 static int update_packet(struct iax_frame *f)
1824 {
1825         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1826         struct ast_iax2_full_hdr *fh = f->data;
1827         /* Mark this as a retransmission */
1828         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1829         /* Update iseqno */
1830         f->iseqno = iaxs[f->callno]->iseqno;
1831         fh->iseqno = f->iseqno;
1832         return 0;
1833 }
1834
1835 static int attempt_transmit(void *data);
1836 static void __attempt_transmit(void *data)
1837 {
1838         /* Attempt to transmit the frame to the remote peer...
1839            Called without iaxsl held. */
1840         struct iax_frame *f = data;
1841         int freeme=0;
1842         int callno = f->callno;
1843         /* Make sure this call is still active */
1844         if (callno) 
1845                 ast_mutex_lock(&iaxsl[callno]);
1846         if (callno && iaxs[callno]) {
1847                 if ((f->retries < 0) /* Already ACK'd */ ||
1848                     (f->retries >= max_retries) /* Too many attempts */) {
1849                                 /* Record an error if we've transmitted too many times */
1850                                 if (f->retries >= max_retries) {
1851                                         if (f->transfer) {
1852                                                 /* Transfer timeout */
1853                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1854                                         } else if (f->final) {
1855                                                 if (f->final) 
1856                                                         iax2_destroy(callno);
1857                                         } else {
1858                                                 if (iaxs[callno]->owner)
1859                                                         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);
1860                                                 iaxs[callno]->error = ETIMEDOUT;
1861                                                 if (iaxs[callno]->owner) {
1862                                                         struct ast_frame fr = { 0, };
1863                                                         /* Hangup the fd */
1864                                                         fr.frametype = AST_FRAME_CONTROL;
1865                                                         fr.subclass = AST_CONTROL_HANGUP;
1866                                                         iax2_queue_frame(callno, &fr);
1867                                                         /* Remember, owner could disappear */
1868                                                         if (iaxs[callno]->owner)
1869                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1870                                                 } else {
1871                                                         if (iaxs[callno]->reg) {
1872                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
1873                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
1874                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1875                                                         }
1876                                                         iax2_destroy(callno);
1877                                                 }
1878                                         }
1879
1880                                 }
1881                                 freeme++;
1882                 } else {
1883                         /* Update it if it needs it */
1884                         update_packet(f);
1885                         /* Attempt transmission */
1886                         send_packet(f);
1887                         f->retries++;
1888                         /* Try again later after 10 times as long */
1889                         f->retrytime *= 10;
1890                         if (f->retrytime > MAX_RETRY_TIME)
1891                                 f->retrytime = MAX_RETRY_TIME;
1892                         /* Transfer messages max out at one second */
1893                         if (f->transfer && (f->retrytime > 1000))
1894                                 f->retrytime = 1000;
1895                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1896                 }
1897         } else {
1898                 /* Make sure it gets freed */
1899                 f->retries = -1;
1900                 freeme++;
1901         }
1902         if (callno)
1903                 ast_mutex_unlock(&iaxsl[callno]);
1904         /* Do not try again */
1905         if (freeme) {
1906                 /* Don't attempt delivery, just remove it from the queue */
1907                 AST_LIST_LOCK(&iaxq.queue);
1908                 AST_LIST_REMOVE(&iaxq.queue, f, list);
1909                 iaxq.count--;
1910                 AST_LIST_UNLOCK(&iaxq.queue);
1911                 f->retrans = -1;
1912                 /* Free the IAX frame */
1913                 iax2_frame_free(f);
1914         }
1915 }
1916
1917 static int attempt_transmit(void *data)
1918 {
1919 #ifdef SCHED_MULTITHREADED
1920         if (schedule_action(__attempt_transmit, data))
1921 #endif          
1922                 __attempt_transmit(data);
1923         return 0;
1924 }
1925
1926 static int iax2_prune_realtime(int fd, int argc, char *argv[])
1927 {
1928         struct iax2_peer *peer;
1929
1930         if (argc != 4)
1931         return RESULT_SHOWUSAGE;
1932         if (!strcmp(argv[3],"all")) {
1933                 reload_config();
1934                 ast_cli(fd, "OK cache is flushed.\n");
1935         } else if ((peer = find_peer(argv[3], 0))) {
1936                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
1937                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
1938                         expire_registry((void*)peer->name);
1939                         ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
1940                 } else {
1941                         ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
1942                 }
1943         } else {
1944                 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
1945         }
1946         
1947         return RESULT_SUCCESS;
1948 }
1949
1950 static int iax2_test_losspct(int fd, int argc, char *argv[])
1951 {
1952        if (argc != 4)
1953                return RESULT_SHOWUSAGE;
1954
1955        test_losspct = atoi(argv[3]);
1956
1957        return RESULT_SUCCESS;
1958 }
1959
1960 #ifdef IAXTESTS
1961 static int iax2_test_late(int fd, int argc, char *argv[])
1962 {
1963         if (argc != 4)
1964                 return RESULT_SHOWUSAGE;
1965
1966         test_late = atoi(argv[3]);
1967
1968         return RESULT_SUCCESS;
1969 }
1970
1971 static int iax2_test_resync(int fd, int argc, char *argv[])
1972 {
1973         if (argc != 4)
1974                 return RESULT_SHOWUSAGE;
1975
1976         test_resync = atoi(argv[3]);
1977
1978         return RESULT_SUCCESS;
1979 }
1980
1981 static int iax2_test_jitter(int fd, int argc, char *argv[])
1982 {
1983         if (argc < 4 || argc > 5)
1984                 return RESULT_SHOWUSAGE;
1985
1986         test_jit = atoi(argv[3]);
1987         if (argc == 5) 
1988                 test_jitpct = atoi(argv[4]);
1989
1990         return RESULT_SUCCESS;
1991 }
1992 #endif /* IAXTESTS */
1993
1994 /*! \brief  peer_status: Report Peer status in character string */
1995 /*      returns 1 if peer is online, -1 if unmonitored */
1996 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
1997 {
1998         int res = 0;
1999         if (peer->maxms) {
2000                 if (peer->lastms < 0) {
2001                         ast_copy_string(status, "UNREACHABLE", statuslen);
2002                 } else if (peer->lastms > peer->maxms) {
2003                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2004                         res = 1;
2005                 } else if (peer->lastms) {
2006                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2007                         res = 1;
2008                 } else {
2009                         ast_copy_string(status, "UNKNOWN", statuslen);
2010                 }
2011         } else { 
2012                 ast_copy_string(status, "Unmonitored", statuslen);
2013                 res = -1;
2014         }
2015         return res;
2016 }
2017
2018 /*! \brief Show one peer in detail */
2019 static int iax2_show_peer(int fd, int argc, char *argv[])
2020 {
2021         char status[30];
2022         char cbuf[256];
2023         struct iax2_peer *peer;
2024         char codec_buf[512];
2025         int x = 0, codec = 0, load_realtime = 0;
2026
2027         if (argc < 4)
2028                 return RESULT_SHOWUSAGE;
2029
2030         load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2031
2032         peer = find_peer(argv[3], load_realtime);
2033         if (peer) {
2034                 ast_cli(fd,"\n\n");
2035                 ast_cli(fd, "  * Name       : %s\n", peer->name);
2036                 ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2037                 ast_cli(fd, "  Context      : %s\n", peer->context);
2038                 ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
2039                 ast_cli(fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2040                 ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2041                 ast_cli(fd, "  Expire       : %d\n", peer->expire);
2042                 ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
2043                 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));
2044                 ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2045                 ast_cli(fd, "  Username     : %s\n", peer->username);
2046                 ast_cli(fd, "  Codecs       : ");
2047                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2048                 ast_cli(fd, "%s\n", codec_buf);
2049
2050                 ast_cli(fd, "  Codec Order  : (");
2051                 for(x = 0; x < 32 ; x++) {
2052                         codec = ast_codec_pref_index(&peer->prefs,x);
2053                         if(!codec)
2054                                 break;
2055                         ast_cli(fd, "%s", ast_getformatname(codec));
2056                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2057                                 ast_cli(fd, "|");
2058                 }
2059
2060                 if (!x)
2061                         ast_cli(fd, "none");
2062                 ast_cli(fd, ")\n");
2063
2064                 ast_cli(fd, "  Status       : ");
2065                 peer_status(peer, status, sizeof(status));      
2066                 ast_cli(fd, "%s\n",status);
2067                 ast_cli(fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2068                 ast_cli(fd,"\n");
2069                 if (ast_test_flag(peer, IAX_TEMPONLY))
2070                         destroy_peer(peer);
2071         } else {
2072                 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2073                 ast_cli(fd,"\n");
2074         }
2075
2076         return RESULT_SUCCESS;
2077 }
2078
2079 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2080 {
2081         int which = 0;
2082         struct iax2_peer *p = NULL;
2083         char *res = NULL;
2084         int wordlen = strlen(word);
2085
2086         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2087         if (pos == 3) {
2088                 AST_LIST_LOCK(&peers);
2089                 AST_LIST_TRAVERSE(&peers, p, entry) {
2090                         if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2091                                 res = ast_strdup(p->name);
2092                                 break;
2093                         }
2094                 }
2095                 AST_LIST_UNLOCK(&peers);
2096         }
2097
2098         return res;
2099 }
2100
2101 static int iax2_show_stats(int fd, int argc, char *argv[])
2102 {
2103         struct iax_frame *cur;
2104         int cnt = 0, dead=0, final=0;
2105
2106         if (argc != 3)
2107                 return RESULT_SHOWUSAGE;
2108
2109         AST_LIST_LOCK(&iaxq.queue);
2110         AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
2111                 if (cur->retries < 0)
2112                         dead++;
2113                 if (cur->final)
2114                         final++;
2115                 cnt++;
2116         }
2117         AST_LIST_UNLOCK(&iaxq.queue);
2118
2119         ast_cli(fd, "    IAX Statistics\n");
2120         ast_cli(fd, "---------------------\n");
2121         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2122         ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2123                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2124
2125         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2126
2127         trunk_timed = trunk_untimed = 0;
2128         if (trunk_maxmtu > trunk_nmaxmtu)
2129                 trunk_nmaxmtu = trunk_maxmtu;
2130         
2131         return RESULT_SUCCESS;
2132 }
2133
2134 /*! \brief Set trunk MTU from CLI */
2135 static int iax2_set_mtu(int fd, int argc, char *argv[])
2136 {
2137         int mtuv;
2138
2139         if (argc != 4)
2140                 return RESULT_SHOWUSAGE; 
2141         if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0) 
2142                 mtuv = MAX_TRUNK_MTU; 
2143         else                                         
2144                 mtuv = atoi(argv[3]); 
2145
2146         if (mtuv == 0) {
2147                 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2148                 global_max_trunk_mtu = 0; 
2149                 return RESULT_SUCCESS; 
2150         }
2151         if (mtuv < 172 || mtuv > 4000) {
2152                 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n"); 
2153                 return RESULT_SHOWUSAGE; 
2154         }
2155         ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2156         global_max_trunk_mtu = mtuv; 
2157         return RESULT_SUCCESS;
2158 }
2159
2160 static int iax2_show_cache(int fd, int argc, char *argv[])
2161 {
2162         struct iax2_dpcache *dp = NULL;
2163         char tmp[1024], *pc = NULL;
2164         int s, x, y;
2165         struct timeval tv;
2166
2167         gettimeofday(&tv, NULL);
2168
2169         AST_LIST_LOCK(&dpcache);
2170
2171         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2172
2173         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2174                 s = dp->expiry.tv_sec - tv.tv_sec;
2175                 tmp[0] = '\0';
2176                 if (dp->flags & CACHE_FLAG_EXISTS)
2177                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2178                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2179                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2180                 if (dp->flags & CACHE_FLAG_CANEXIST)
2181                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2182                 if (dp->flags & CACHE_FLAG_PENDING)
2183                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2184                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2185                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2186                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2187                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2188                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2189                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2190                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2191                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2192                 /* Trim trailing pipe */
2193                 if (!ast_strlen_zero(tmp))
2194                         tmp[strlen(tmp) - 1] = '\0';
2195                 else
2196                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2197                 y=0;
2198                 pc = strchr(dp->peercontext, '@');
2199                 if (!pc)
2200                         pc = dp->peercontext;
2201                 else
2202                         pc++;
2203                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2204                         if (dp->waiters[x] > -1)
2205                                 y++;
2206                 if (s > 0)
2207                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2208                 else
2209                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2210         }
2211
2212         AST_LIST_LOCK(&dpcache);
2213
2214         return RESULT_SUCCESS;
2215 }
2216
2217 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2218
2219 static void unwrap_timestamp(struct iax_frame *fr)
2220 {
2221         int x;
2222
2223         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2224                 x = fr->ts - iaxs[fr->callno]->last;
2225                 if (x < -50000) {
2226                         /* Sudden big jump backwards in timestamp:
2227                            What likely happened here is that miniframe timestamp has circled but we haven't
2228                            gotten the update from the main packet.  We'll just pretend that we did, and
2229                            update the timestamp appropriately. */
2230                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2231                         if (option_debug && iaxdebug)
2232                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed forward timestamp\n");
2233                 }
2234                 if (x > 50000) {
2235                         /* Sudden apparent big jump forwards in timestamp:
2236                            What's likely happened is this is an old miniframe belonging to the previous
2237                            top-16-bit timestamp that has turned up out of order.
2238                            Adjust the timestamp appropriately. */
2239                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2240                         if (option_debug && iaxdebug)
2241                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed back timestamp\n");
2242                 }
2243         }
2244 }
2245
2246 static int get_from_jb(void *p);
2247
2248 static void update_jbsched(struct chan_iax2_pvt *pvt)
2249 {
2250         int when;
2251         
2252         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2253         
2254         when = jb_next(pvt->jb) - when;
2255         
2256         if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2257         
2258         if(when <= 0) {
2259                 /* XXX should really just empty until when > 0.. */
2260                 when = 1;
2261         }
2262         
2263         pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2264         
2265         /* Signal scheduler thread */
2266         signal_condition(&sched_lock, &sched_cond);
2267 }
2268
2269 static void __get_from_jb(void *p) 
2270 {
2271         int callno = PTR_TO_CALLNO(p);
2272         struct chan_iax2_pvt *pvt = NULL;
2273         struct iax_frame *fr;
2274         jb_frame frame;
2275         int ret;
2276         long now;
2277         long next;
2278         struct timeval tv;
2279         
2280         /* Make sure we have a valid private structure before going on */
2281         ast_mutex_lock(&iaxsl[callno]);
2282         pvt = iaxs[callno];
2283         if (!pvt) {
2284                 /* No go! */
2285                 ast_mutex_unlock(&iaxsl[callno]);
2286                 return;
2287         }
2288
2289         pvt->jbid = -1;
2290         
2291         gettimeofday(&tv,NULL);
2292         /* round up a millisecond since ast_sched_runq does; */
2293         /* prevents us from spinning while waiting for our now */
2294         /* to catch up with runq's now */
2295         tv.tv_usec += 1000;
2296         
2297         now = ast_tvdiff_ms(tv, pvt->rxcore);
2298         
2299         if(now >= (next = jb_next(pvt->jb))) {
2300                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2301                 switch(ret) {
2302                 case JB_OK:
2303                         fr = frame.data;
2304                         __do_deliver(fr);
2305                         break;
2306                 case JB_INTERP:
2307                 {
2308                         struct ast_frame af;
2309                         
2310                         /* create an interpolation frame */
2311                         af.frametype = AST_FRAME_VOICE;
2312                         af.subclass = pvt->voiceformat;
2313                         af.datalen  = 0;
2314                         af.samples  = frame.ms * 8;
2315                         af.mallocd  = 0;
2316                         af.src  = "IAX2 JB interpolation";
2317                         af.data  = NULL;
2318                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2319                         af.offset=AST_FRIENDLY_OFFSET;
2320                         
2321                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2322                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2323                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE))
2324                                 iax2_queue_frame(callno, &af);
2325                 }
2326                 break;
2327                 case JB_DROP:
2328                         iax2_frame_free(frame.data);
2329                         break;
2330                 case JB_NOFRAME:
2331                 case JB_EMPTY:
2332                         /* do nothing */
2333                         break;
2334                 default:
2335                         /* shouldn't happen */
2336                         break;
2337                 }
2338         }
2339         update_jbsched(pvt);
2340         ast_mutex_unlock(&iaxsl[callno]);
2341 }
2342
2343 static int get_from_jb(void *data)
2344 {
2345 #ifdef SCHED_MULTITHREADED
2346         if (schedule_action(__get_from_jb, data))
2347 #endif          
2348                 __get_from_jb(data);
2349         return 0;
2350 }
2351
2352 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2353 {
2354         int type, len;
2355         int ret;
2356         int needfree = 0;
2357
2358         /* Attempt to recover wrapped timestamps */
2359         unwrap_timestamp(fr);
2360         
2361
2362         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2363         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2364                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2365         else {
2366 #if 0
2367                 if (option_debug)
2368                         ast_log(LOG_DEBUG, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2369 #endif
2370                 fr->af.delivery = ast_tv(0,0);
2371         }
2372
2373         type = JB_TYPE_CONTROL;
2374         len = 0;
2375
2376         if(fr->af.frametype == AST_FRAME_VOICE) {
2377                 type = JB_TYPE_VOICE;
2378                 len = ast_codec_get_samples(&fr->af) / 8;
2379         } else if(fr->af.frametype == AST_FRAME_CNG) {
2380                 type = JB_TYPE_SILENCE;
2381         }
2382
2383         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2384                 if (tsout)
2385                         *tsout = fr->ts;
2386                 __do_deliver(fr);
2387                 return -1;
2388         }
2389
2390         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2391          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2392         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2393             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2394             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2395                 jb_frame frame;
2396
2397                 /* deliver any frames in the jb */
2398                 while(jb_getall(iaxs[fr->callno]->jb,&frame) == JB_OK)
2399                         __do_deliver(frame.data);
2400
2401                 jb_reset(iaxs[fr->callno]->jb);
2402
2403                 if (iaxs[fr->callno]->jbid > -1)
2404                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2405
2406                 iaxs[fr->callno]->jbid = -1;
2407
2408                 /* deliver this frame now */
2409                 if (tsout)
2410                         *tsout = fr->ts;
2411                 __do_deliver(fr);
2412                 return -1;
2413         }
2414
2415         /* insert into jitterbuffer */
2416         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2417         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2418                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2419         if (ret == JB_DROP) {
2420                 needfree++;
2421         } else if (ret == JB_SCHED) {
2422                 update_jbsched(iaxs[fr->callno]);
2423         }
2424         if (tsout)
2425                 *tsout = fr->ts;
2426         if (needfree) {
2427                 /* Free our iax frame */
2428                 iax2_frame_free(fr);
2429                 return -1;
2430         }
2431         return 0;
2432 }
2433
2434 static int iax2_transmit(struct iax_frame *fr)
2435 {
2436         /* Lock the queue and place this packet at the end */
2437         /* By setting this to 0, the network thread will send it for us, and
2438            queue retransmission if necessary */
2439         fr->sentyet = 0;
2440         AST_LIST_LOCK(&iaxq.queue);
2441         AST_LIST_INSERT_TAIL(&iaxq.queue, fr, list);
2442         iaxq.count++;
2443         AST_LIST_UNLOCK(&iaxq.queue);
2444         /* Wake up the network and scheduler thread */
2445         pthread_kill(netthreadid, SIGURG);
2446         signal_condition(&sched_lock, &sched_cond);
2447         return 0;
2448 }
2449
2450
2451
2452 static int iax2_digit_begin(struct ast_channel *c, char digit)
2453 {
2454         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2455 }
2456
2457 static int iax2_digit_end(struct ast_channel *c, char digit)
2458 {
2459         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2460 }
2461
2462 static int iax2_sendtext(struct ast_channel *c, const char *text)
2463 {
2464         
2465         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2466                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2467 }
2468
2469 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2470 {
2471         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2472 }
2473
2474 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2475 {
2476         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2477 }
2478
2479 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2480 {
2481         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2482         ast_mutex_lock(&iaxsl[callno]);
2483         if (iaxs[callno])
2484                 iaxs[callno]->owner = newchan;
2485         else
2486                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2487         ast_mutex_unlock(&iaxsl[callno]);
2488         return 0;
2489 }
2490
2491 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2492 {
2493         struct ast_variable *var;
2494         struct ast_variable *tmp;
2495         struct iax2_peer *peer=NULL;
2496         time_t regseconds = 0, nowtime;
2497         int dynamic=0;
2498
2499         if (peername)
2500                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2501         else {
2502                 char porta[25];
2503                 sprintf(porta, "%d", ntohs(sin->sin_port));
2504                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2505                 if (var) {
2506                         /* We'll need the peer name in order to build the structure! */
2507                         for (tmp = var; tmp; tmp = tmp->next) {
2508                                 if (!strcasecmp(tmp->name, "name"))
2509                                         peername = tmp->value;
2510                         }
2511                 }
2512         }
2513         if (!var)
2514                 return NULL;
2515
2516         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2517         
2518         if (!peer)
2519                 return NULL;
2520
2521         for (tmp = var; tmp; tmp = tmp->next) {
2522                 /* Make sure it's not a user only... */
2523                 if (!strcasecmp(tmp->name, "type")) {
2524                         if (strcasecmp(tmp->value, "friend") &&
2525                             strcasecmp(tmp->value, "peer")) {
2526                                 /* Whoops, we weren't supposed to exist! */
2527                                 destroy_peer(peer);
2528                                 peer = NULL;
2529                                 break;
2530                         } 
2531                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2532                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2533                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2534                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2535                 } else if (!strcasecmp(tmp->name, "port")) {
2536                         peer->addr.sin_port = htons(atoi(tmp->value));
2537                 } else if (!strcasecmp(tmp->name, "host")) {
2538                         if (!strcasecmp(tmp->value, "dynamic"))
2539                                 dynamic = 1;
2540                 }
2541         }
2542         if (!peer)
2543                 return NULL;
2544
2545         ast_variables_destroy(var);
2546
2547         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2548                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2549                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2550                         if (peer->expire > -1)
2551                                 ast_sched_del(sched, peer->expire);
2552                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2553                 }
2554                 AST_LIST_LOCK(&peers);
2555                 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2556                 AST_LIST_UNLOCK(&peers);
2557                 if (ast_test_flag(peer, IAX_DYNAMIC))
2558                         reg_source_db(peer);
2559         } else {
2560                 ast_set_flag(peer, IAX_TEMPONLY);       
2561         }
2562
2563         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2564                 time(&nowtime);
2565                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2566                         memset(&peer->addr, 0, sizeof(peer->addr));
2567                         realtime_update_peer(peer->name, &peer->addr, 0);
2568                         if (option_debug)
2569                                 ast_log(LOG_DEBUG, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2570                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2571                 }
2572                 else {
2573                         if (option_debug)
2574                                 ast_log(LOG_DEBUG, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2575                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2576                 }
2577         }
2578
2579         return peer;
2580 }
2581
2582 static struct iax2_user *realtime_user(const char *username)
2583 {
2584         struct ast_variable *var;
2585         struct ast_variable *tmp;
2586         struct iax2_user *user=NULL;
2587
2588         var = ast_load_realtime("iaxusers", "name", username, NULL);
2589         if (!var)
2590                 return NULL;
2591
2592         tmp = var;
2593         while(tmp) {
2594                 /* Make sure it's not a peer only... */
2595                 if (!strcasecmp(tmp->name, "type")) {
2596                         if (strcasecmp(tmp->value, "friend") &&
2597                             strcasecmp(tmp->value, "user")) {
2598                                 return NULL;
2599                         } 
2600                 }
2601                 tmp = tmp->next;
2602         }
2603
2604         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2605         if (!user)
2606                 return NULL;
2607
2608         ast_variables_destroy(var);
2609
2610         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2611                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2612                 AST_LIST_LOCK(&users);
2613                 AST_LIST_INSERT_HEAD(&users, user, entry);
2614                 AST_LIST_UNLOCK(&users);
2615         } else {
2616                 ast_set_flag(user, IAX_TEMPONLY);       
2617         }
2618
2619         return user;
2620 }
2621
2622 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2623 {
2624         char port[10];
2625         char regseconds[20];
2626         
2627         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2628         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2629         ast_update_realtime("iaxpeers", "name", peername, 
2630                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
2631                 "regseconds", regseconds, NULL);
2632 }
2633
2634 struct create_addr_info {
2635         int capability;
2636         unsigned int flags;
2637         int maxtime;
2638         int encmethods;
2639         int found;
2640         int sockfd;
2641         int adsi;
2642         char username[80];
2643         char secret[80];
2644         char outkey[80];
2645         char timezone[80];
2646         char prefs[32];
2647         char context[AST_MAX_CONTEXT];
2648         char peercontext[AST_MAX_CONTEXT];
2649         char mohinterpret[MAX_MUSICCLASS];
2650         char mohsuggest[MAX_MUSICCLASS];
2651 };
2652
2653 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2654 {
2655         struct ast_hostent ahp;
2656         struct hostent *hp;
2657         struct iax2_peer *peer;
2658
2659         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2660         cai->sockfd = defaultsockfd;
2661         cai->maxtime = 0;
2662         sin->sin_family = AF_INET;
2663
2664         if (!(peer = find_peer(peername, 1))) {
2665                 cai->found = 0;
2666
2667                 hp = ast_gethostbyname(peername, &ahp);
2668                 if (hp) {
2669                         memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
2670                         sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2671                         /* use global iax prefs for unknown peer/user */
2672                         ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2673                         return 0;
2674                 } else {
2675                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
2676                         return -1;
2677                 }
2678         }
2679
2680         cai->found = 1;
2681         
2682         /* if the peer has no address (current or default), return failure */
2683         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2684                 if (ast_test_flag(peer, IAX_TEMPONLY))
2685                         destroy_peer(peer);
2686                 return -1;
2687         }
2688
2689         /* if the peer is being monitored and is currently unreachable, return failure */
2690         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2691                 if (ast_test_flag(peer, IAX_TEMPONLY))
2692                         destroy_peer(peer);
2693                 return -1;
2694         }
2695
2696         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2697         cai->maxtime = peer->maxms;
2698         cai->capability = peer->capability;
2699         cai->encmethods = peer->encmethods;
2700         cai->sockfd = peer->sockfd;
2701         cai->adsi = peer->adsi;
2702         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2703         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2704         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2705         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2706         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2707         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2708         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2709         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2710         if (ast_strlen_zero(peer->dbsecret)) {
2711                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2712         } else {
2713                 char *family;
2714                 char *key = NULL;
2715
2716                 family = ast_strdupa(peer->dbsecret);
2717                 key = strchr(family, '/');
2718                 if (key)
2719                         *key++ = '\0';
2720                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2721                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2722                         if (ast_test_flag(peer, IAX_TEMPONLY))
2723                                 destroy_peer(peer);
2724                         return -1;
2725                 }
2726         }
2727
2728         if (peer->addr.sin_addr.s_addr) {
2729                 sin->sin_addr = peer->addr.sin_addr;
2730                 sin->sin_port = peer->addr.sin_port;
2731         } else {
2732                 sin->sin_addr = peer->defaddr.sin_addr;
2733                 sin->sin_port = peer->defaddr.sin_port;
2734         }
2735
2736         if (ast_test_flag(peer, IAX_TEMPONLY))
2737                 destroy_peer(peer);
2738
2739         return 0;
2740 }
2741
2742 static void __auto_congest(void *nothing)
2743 {
2744         int callno = PTR_TO_CALLNO(nothing);
2745         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2746         ast_mutex_lock(&iaxsl[callno]);
2747         if (iaxs[callno]) {
2748                 iaxs[callno]->initid = -1;
2749                 iax2_queue_frame(callno, &f);
2750                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2751         }
2752         ast_mutex_unlock(&iaxsl[callno]);
2753 }
2754
2755 static int auto_congest(void *data)
2756 {
2757 #ifdef SCHED_MULTITHREADED
2758         if (schedule_action(__auto_congest, data))
2759 #endif          
2760                 __auto_congest(data);
2761         return 0;
2762 }
2763
2764 static unsigned int iax2_datetime(const char *tz)
2765 {
2766         time_t t;
2767         struct tm tm;
2768         unsigned int tmp;
2769         time(&t);
2770         localtime_r(&t, &tm);
2771         if (!ast_strlen_zero(tz))
2772                 ast_localtime(&t, &tm, tz);
2773         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
2774         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
2775         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
2776         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
2777         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
2778         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
2779         return tmp;
2780 }
2781
2782 struct parsed_dial_string {
2783         char *username;
2784         char *password;
2785         char *key;
2786         char *peer;
2787         char *port;
2788         char *exten;
2789         char *context;
2790         char *options;
2791 };
2792
2793 /*!
2794  * \brief Parses an IAX dial string into its component parts.
2795  * \param data the string to be parsed
2796  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2797  * \return nothing
2798  *
2799  * This function parses the string and fills the structure
2800  * with pointers to its component parts. The input string
2801  * will be modified.
2802  *
2803  * \note This function supports both plaintext passwords and RSA
2804  * key names; if the password string is formatted as '[keyname]',
2805  * then the keyname will be placed into the key field, and the
2806  * password field will be set to NULL.
2807  *
2808  * \note The dial string format is:
2809  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
2810  */
2811 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2812 {
2813         if (ast_strlen_zero(data))
2814                 return;
2815
2816         pds->peer = strsep(&data, "/");
2817         pds->exten = strsep(&data, "/");
2818         pds->options = data;
2819
2820         if (pds->exten) {
2821                 data = pds->exten;
2822                 pds->exten = strsep(&data, "@");
2823                 pds->context = data;
2824         }
2825
2826         if (strchr(pds->peer, '@')) {
2827                 data = pds->peer;
2828                 pds->username = strsep(&data, "@");
2829                 pds->peer = data;
2830         }
2831
2832         if (pds->username) {
2833                 data = pds->username;
2834                 pds->username = strsep(&data, ":");
2835                 pds->password = data;
2836         }
2837
2838         data = pds->peer;
2839         pds->peer = strsep(&data, ":");
2840         pds->port = data;
2841
2842         /* check for a key name wrapped in [] in the secret position, if found,
2843            move it to the key field instead
2844         */
2845         if (pds->password && (pds->password[0] == '[')) {
2846                 pds->key = ast_strip_quoted(pds->password, "[", "]");
2847                 pds->password = NULL;
2848         }
2849 }
2850
2851 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2852 {
2853         struct sockaddr_in sin;
2854         char *l=NULL, *n=NULL, *tmpstr;
2855         struct iax_ie_data ied;
2856         char *defaultrdest = "s";
2857         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2858         struct parsed_dial_string pds;
2859         struct create_addr_info cai;
2860
2861         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2862                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
2863                 return -1;
2864         }
2865
2866         memset(&cai, 0, sizeof(cai));
2867         cai.encmethods = iax2_encryption;
2868
2869         memset(&pds, 0, sizeof(pds));
2870         tmpstr = ast_strdupa(dest);
2871         parse_dial_string(tmpstr, &pds);
2872
2873         if (!pds.exten)
2874                 pds.exten = defaultrdest;
2875
2876         if (create_addr(pds.peer, &sin, &cai)) {
2877                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
2878                 return -1;
2879         }
2880
2881         if (!pds.username && !ast_strlen_zero(cai.username))
2882                 pds.username = cai.username;
2883         if (!pds.password && !ast_strlen_zero(cai.secret))
2884                 pds.password = cai.secret;
2885         if (!pds.key && !ast_strlen_zero(cai.outkey))
2886                 pds.key = cai.outkey;
2887         if (!pds.context && !ast_strlen_zero(cai.peercontext))
2888                 pds.context = cai.peercontext;
2889
2890         /* Keep track of the context for outgoing calls too */
2891         ast_copy_string(c->context, cai.context, sizeof(c->context));
2892
2893         if (pds.port)
2894                 sin.sin_port = htons(atoi(pds.port));
2895
2896         l = c->cid.cid_num;
2897         n = c->cid.cid_name;
2898
2899         /* Now build request */ 
2900         memset(&ied, 0, sizeof(ied));
2901
2902         /* On new call, first IE MUST be IAX version of caller */
2903         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2904         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
2905         if (pds.options && strchr(pds.options, 'a')) {
2906                 /* Request auto answer */
2907                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
2908         }
2909
2910         iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
2911
2912         if (l) {
2913                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
2914                 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2915         } else {
2916                 if (n)
2917                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2918                 else
2919                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
2920         }
2921
2922         iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
2923         iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
2924
2925         if (n)
2926                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
2927         if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
2928                 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
2929
2930         if (!ast_strlen_zero(c->language))
2931                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
2932         if (!ast_strlen_zero(c->cid.cid_dnid))
2933                 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
2934         if (!ast_strlen_zero(c->cid.cid_rdnis))
2935                 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
2936
2937         if (pds.context)
2938                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
2939
2940         if (pds.username)
2941                 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
2942
2943         if (cai.encmethods)
2944                 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
2945
2946         ast_mutex_lock(&iaxsl[callno]);
2947
2948         if (!ast_strlen_zero(c->context))
2949                 ast_string_field_set(iaxs[callno], context, c->context);
2950
2951         if (pds.username)
2952                 ast_string_field_set(iaxs[callno], username, pds.username);
2953
2954         iaxs[callno]->encmethods = cai.encmethods;
2955
2956         iaxs[callno]->adsi = cai.adsi;
2957         
2958         ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
2959         ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
2960
2961         if (pds.key)
2962                 ast_string_field_set(iaxs[callno], outkey, pds.key);
2963         if (pds.password)
2964                 ast_string_field_set(iaxs[callno], secret, pds.password);
2965
2966         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
2967         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
2968         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
2969         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
2970
2971         if (iaxs[callno]->maxtime) {
2972                 /* Initialize pingtime and auto-congest time */
2973                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
2974                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
2975         } else if (autokill) {
2976                 iaxs[callno]->pingtime = autokill / 2;
2977                 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
2978         }
2979
2980         /* send the command using the appropriate socket for this peer */
2981         iaxs[callno]->sockfd = cai.sockfd;
2982
2983         /* Transmit the string in a "NEW" request */
2984         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
2985
2986         ast_mutex_unlock(&iaxsl[callno]);
2987         ast_setstate(c, AST_STATE_RINGING);
2988         
2989         return 0;
2990 }
2991
2992 static int iax2_hangup(struct ast_channel *c) 
2993 {
2994         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2995         int alreadygone;
2996         struct iax_ie_data ied;
2997         memset(&ied, 0, sizeof(ied));
2998         ast_mutex_lock(&iaxsl[callno]);
2999         if (callno && iaxs[callno]) {
3000                 if (option_debug)
3001                         ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
3002                 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
3003                 /* Send the hangup unless we have had a transmission error or are already gone */
3004                 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
3005                 if (!iaxs[callno]->error && !alreadygone) 
3006                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
3007                 /* Explicitly predestroy it */
3008                 iax2_predestroy(callno);
3009                 /* If we were already gone to begin with, destroy us now */
3010                 if (alreadygone) {
3011                         if (option_debug)
3012                                 ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
3013                         iax2_destroy(callno);
3014                 }
3015         }
3016         ast_mutex_unlock(&iaxsl[callno]);
3017         if (option_verbose > 2) 
3018                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
3019         return 0;
3020 }
3021
3022 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
3023 {
3024         struct ast_option_header *h;
3025         int res;
3026
3027         switch (option) {
3028         case AST_OPTION_TXGAIN:
3029         case AST_OPTION_RXGAIN:
3030                 /* these two cannot be sent, because they require a result */
3031                 errno = ENOSYS;
3032                 return -1;
3033         default:
3034                 if (!(h = ast_malloc(datalen + sizeof(*h))))
3035                         return -1;
3036
3037                 h->flag = AST_OPTION_FLAG_REQUEST;
3038                 h->option = htons(option);
3039                 memcpy(h->data, data, datalen);
3040                 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
3041                                           AST_CONTROL_OPTION, 0, (unsigned char *) h,
3042                                           datalen + sizeof(*h), -1);
3043                 free(h);
3044                 return res;
3045         }
3046 }
3047
3048 static struct ast_frame *iax2_read(struct ast_channel *c) 
3049 {
3050         ast_log(LOG_NOTICE, "I should never be called!\n");
3051         return &ast_null_frame;
3052 }
3053
3054 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
3055 {
3056         int res;
3057         struct iax_ie_data ied0;
3058         struct iax_ie_data ied1;
3059         unsigned int transferid = (unsigned int)ast_random();
3060         memset(&ied0, 0, sizeof(ied0));
3061         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
3062         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
3063         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
3064
3065         memset(&ied1, 0, sizeof(ied1));
3066         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
3067         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
3068         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
3069         
3070         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
3071         if (res)
3072                 return -1;
3073         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
3074         if (res)
3075                 return -1;
3076         iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3077         iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3078         return 0;
3079 }
3080
3081 static void lock_both(unsigned short callno0, unsigned short callno1)
3082 {
3083         ast_mutex_lock(&iaxsl[callno0]);
3084         while (ast_mutex_trylock(&iaxsl[callno1])) {
3085                 ast_mutex_unlock(&iaxsl[callno0]);
3086                 usleep(10);
3087                 ast_mutex_lock(&iaxsl[callno0]);
3088         }
3089 }
3090
3091 static void unlock_both(unsigned short callno0, unsigned short callno1)
3092 {
3093         ast_mutex_unlock(&iaxsl[callno1]);
3094         ast_mutex_unlock(&iaxsl[callno0]);
3095 }
3096
3097 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)
3098 {
3099         struct ast_channel *cs[3];
3100         struct ast_channel *who, *other;
3101         int to = -1;
3102         int res = -1;
3103         int transferstarted=0;
3104         struct ast_frame *f;
3105         unsigned short callno0 = PTR_TO_CALLNO(c0->tech_pvt);
3106         unsigned short callno1 = PTR_TO_CALLNO(c1->tech_pvt);
3107         struct timeval waittimer = {0, 0}, tv;
3108
3109         lock_both(callno0, callno1);
3110         /* Put them in native bridge mode */
3111         if (!flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) {
3112                 iaxs[callno0]->bridgecallno = callno1;
3113                 iaxs[callno1]->bridgecallno = callno0;
3114         }
3115         unlock_both(callno0, callno1);
3116
3117         /* If not, try to bridge until we can execute a transfer, if we can */
3118         cs[0] = c0;
3119         cs[1] = c1;
3120         for (/* ever */;;) {
3121                 /* Check in case we got masqueraded into */
3122                 if ((c0->tech != &iax2_tech) || (c1->tech != &iax2_tech)) {
3123                         if (option_verbose > 2)
3124                                 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
3125                         /* Remove from native mode */
3126                         if (c0->tech == &iax2_tech) {
3127                                 ast_mutex_lock(&iaxsl[callno0]);
3128                                 iaxs[callno0]->bridgecallno = 0;
3129                                 ast_mutex_unlock(&iaxsl[callno0]);
3130                         }
3131                         if (c1->tech == &iax2_tech) {
3132                                 ast_mutex_lock(&iaxsl[callno1]);
3133                                 iaxs[callno1]->bridgecallno = 0;
3134                                 ast_mutex_unlock(&iaxsl[callno1]);
3135                         }
3136                         return AST_BRIDGE_FAILED_NOWARN;
3137                 }
3138                 if (c0->nativeformats != c1->nativeformats) {
3139                         if (option_verbose > 2) {
3140                                 char buf0[255];
3141                                 char buf1[255];
3142                                 ast_getformatname_multiple(buf0, sizeof(buf0) -1, c0->nativeformats);
3143                                 ast_getformatname_multiple(buf1, sizeof(buf1) -1, c1->nativeformats);
3144                                 ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs %d[%s] %d[%s] , can't native bridge...\n", c0->nativeformats, buf0, c1->nativeformats, buf1);
3145                         }
3146                         /* Remove from native mode */
3147                         lock_both(callno0, callno1);
3148                         iaxs[callno0]->bridgecallno = 0;
3149                         iaxs[callno1]->bridgecallno = 0;
3150                         unlock_both(callno0, callno1);
3151                         return AST_BRIDGE_FAILED_NOWARN;
3152                 }
3153                 /* check if transfered and if we really want native bridging */
3154                 if (!transferstarted && !ast_test_flag(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag(iaxs[callno1], IAX_NOTRANSFER)) {
3155                         /* Try the transfer */
3156                         if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
3157                                                         ast_test_flag(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag(iaxs[callno1], IAX_TRANSFERMEDIA)))
3158                                 ast_log(LOG_WARNING, "Unable to start the transfer\n");
3159                         transferstarted = 1;
3160                 }
3161                 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
3162                         /* Call has been transferred.  We're no longer involved */
3163                         gettimeofday(&tv, NULL);
3164                         if (ast_tvzero(waittimer)) {
3165                                 waittimer = tv;
3166                         } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
3167                                 c0->_softhangup |= AST_SOFTHANGUP_DEV;
3168                                 c1->_softhangup |= AST_SOFTHANGUP_DEV;
3169                                 *fo = NULL;
3170                                 *rc = c0;
3171                                 res = AST_BRIDGE_COMPLETE;
3172                                 break;
3173                         }
3174                 }
3175                 to = 1000;