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