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