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