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