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