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