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