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