Lock iax2 pvt structure when passing off to the AMI function, and make sure it exists...
[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 /*! \brief Send manager event at call setup to link between Asterisk channel name
899         and IAX2 call identifiers */
900 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt) 
901 {
902         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
903                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
904                 pvt->owner ? pvt->owner->name : "",
905                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
906 }
907
908
909 static void insert_idle_thread(struct iax2_thread *thread)
910 {
911         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
912                 AST_LIST_LOCK(&dynamic_list);
913                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
914                 AST_LIST_UNLOCK(&dynamic_list);
915         } else {
916                 AST_LIST_LOCK(&idle_list);
917                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
918                 AST_LIST_UNLOCK(&idle_list);
919         }
920
921         return;
922 }
923
924 static struct iax2_thread *find_idle_thread(void)
925 {
926         pthread_attr_t attr;
927         struct iax2_thread *thread = NULL;
928
929         /* Pop the head of the idle list off */
930         AST_LIST_LOCK(&idle_list);
931         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
932         AST_LIST_UNLOCK(&idle_list);
933
934         /* If we popped a thread off the idle list, just return it */
935         if (thread)
936                 return thread;
937
938         /* Pop the head of the dynamic list off */
939         AST_LIST_LOCK(&dynamic_list);
940         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
941         AST_LIST_UNLOCK(&dynamic_list);
942
943         /* If we popped a thread off the dynamic list, just return it */
944         if (thread)
945                 return thread;
946
947         /* If we can't create a new dynamic thread for any reason, return no thread at all */
948         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
949                 return NULL;
950
951         /* Set default values */
952         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
953         thread->type = IAX_THREAD_TYPE_DYNAMIC;
954
955         /* Initialize lock and condition */
956         ast_mutex_init(&thread->lock);
957         ast_cond_init(&thread->cond, NULL);
958
959         /* Create thread and send it on it's way */
960         pthread_attr_init(&attr);
961         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    
962         if (ast_pthread_create_background(&thread->threadid, &attr, iax2_process_thread, thread)) {
963                 ast_cond_destroy(&thread->cond);
964                 ast_mutex_destroy(&thread->lock);
965                 free(thread);
966                 thread = NULL;
967         }
968
969         return thread;
970 }
971
972 #ifdef SCHED_MULTITHREADED
973 static int __schedule_action(void (*func)(void *data), void *data, const char *funcname)
974 {
975         struct iax2_thread *thread = NULL;
976         static time_t lasterror;
977         static time_t t;
978
979         thread = find_idle_thread();
980
981         if (thread != NULL) {
982                 thread->schedfunc = func;
983                 thread->scheddata = data;
984                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
985 #ifdef DEBUG_SCHED_MULTITHREAD
986                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
987 #endif
988                 signal_condition(&thread->lock, &thread->cond);
989                 return 0;
990         }
991         time(&t);
992         if (t != lasterror) 
993                 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
994         lasterror = t;
995
996         return -1;
997 }
998 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
999 #endif
1000
1001 static int send_ping(void *data);
1002
1003 static void __send_ping(void *data)
1004 {
1005         int callno = (long)data;
1006         ast_mutex_lock(&iaxsl[callno]);
1007         if (iaxs[callno] && iaxs[callno]->pingid != -1) {
1008                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1009                 iaxs[callno]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, data);
1010         }
1011         ast_mutex_unlock(&iaxsl[callno]);
1012 }
1013
1014 static int send_ping(void *data)
1015 {
1016 #ifdef SCHED_MULTITHREADED
1017         if (schedule_action(__send_ping, data))
1018 #endif          
1019                 __send_ping(data);
1020         return 0;
1021 }
1022
1023 static int get_encrypt_methods(const char *s)
1024 {
1025         int e;
1026         if (!strcasecmp(s, "aes128"))
1027                 e = IAX_ENCRYPT_AES128;
1028         else if (ast_true(s))
1029                 e = IAX_ENCRYPT_AES128;
1030         else
1031                 e = 0;
1032         return e;
1033 }
1034
1035 static int send_lagrq(void *data);
1036
1037 static void __send_lagrq(void *data)
1038 {
1039         int callno = (long)data;
1040         /* Ping only if it's real not if it's bridged */
1041         ast_mutex_lock(&iaxsl[callno]);
1042         if (iaxs[callno] && iaxs[callno]->lagid != -1) {
1043                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1044                 iaxs[callno]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1045         }
1046         ast_mutex_unlock(&iaxsl[callno]);
1047 }
1048
1049 static int send_lagrq(void *data)
1050 {
1051 #ifdef SCHED_MULTITHREADED
1052         if (schedule_action(__send_lagrq, data))
1053 #endif          
1054                 __send_lagrq(data);
1055         return 0;
1056 }
1057
1058 static unsigned char compress_subclass(int subclass)
1059 {
1060         int x;
1061         int power=-1;
1062         /* If it's 128 or smaller, just return it */
1063         if (subclass < IAX_FLAG_SC_LOG)
1064                 return subclass;
1065         /* Otherwise find its power */
1066         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1067                 if (subclass & (1 << x)) {
1068                         if (power > -1) {
1069                                 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1070                                 return 0;
1071                         } else
1072                                 power = x;
1073                 }
1074         }
1075         return power | IAX_FLAG_SC_LOG;
1076 }
1077
1078 static int uncompress_subclass(unsigned char csub)
1079 {
1080         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1081         if (csub & IAX_FLAG_SC_LOG) {
1082                 /* special case for 'compressed' -1 */
1083                 if (csub == 0xff)
1084                         return -1;
1085                 else
1086                         return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1087         }
1088         else
1089                 return csub;
1090 }
1091
1092 static struct iax2_peer *find_peer(const char *name, int realtime) 
1093 {
1094         struct iax2_peer *peer = NULL;
1095
1096         /* Grab peer from linked list */
1097         AST_LIST_LOCK(&peers);
1098         AST_LIST_TRAVERSE(&peers, peer, entry) {
1099                 if (!strcasecmp(peer->name, name)) {
1100                         break;
1101                 }
1102         }
1103         AST_LIST_UNLOCK(&peers);
1104
1105         /* Now go for realtime if applicable */
1106         if(!peer && realtime)
1107                 peer = realtime_peer(name, NULL);
1108         return peer;
1109 }
1110
1111 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1112 {
1113         struct iax2_peer *peer = NULL;
1114         int res = 0;
1115
1116         if (lockpeer)
1117                 AST_LIST_LOCK(&peers);
1118         AST_LIST_TRAVERSE(&peers, peer, entry) {
1119                 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1120                     (peer->addr.sin_port == sin.sin_port)) {
1121                         ast_copy_string(host, peer->name, len);
1122                         res = 1;
1123                         break;
1124                 }
1125         }
1126         if (lockpeer)
1127                 AST_LIST_UNLOCK(&peers);
1128         if (!peer) {
1129                 peer = realtime_peer(NULL, &sin);
1130                 if (peer) {
1131                         ast_copy_string(host, peer->name, len);
1132                         if (ast_test_flag(peer, IAX_TEMPONLY))
1133                                 destroy_peer(peer);
1134                         res = 1;
1135                 }
1136         }
1137
1138         return res;
1139 }
1140
1141 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1142 {
1143         struct chan_iax2_pvt *tmp;
1144         jb_conf jbconf;
1145
1146         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1147                 return NULL;
1148
1149         if (ast_string_field_init(tmp, 32)) {
1150                 free(tmp);
1151                 tmp = NULL;
1152                 return NULL;
1153         }
1154                 
1155         tmp->prefs = prefs;
1156         tmp->pingid = -1;
1157         tmp->lagid = -1;
1158         tmp->autoid = -1;
1159         tmp->authid = -1;
1160         tmp->initid = -1;
1161
1162         ast_string_field_set(tmp,exten, "s");
1163         ast_string_field_set(tmp,host, host);
1164
1165         tmp->jb = jb_new();
1166         tmp->jbid = -1;
1167         jbconf.max_jitterbuf = maxjitterbuffer;
1168         jbconf.resync_threshold = resyncthreshold;
1169         jbconf.max_contig_interp = maxjitterinterps;
1170         jbconf.target_extra = jittertargetextra;
1171         jb_setconf(tmp->jb,&jbconf);
1172
1173         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1174
1175         return tmp;
1176 }
1177
1178 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1179 {
1180         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1181         if (new) {
1182                 size_t mallocd_datalen = new->mallocd_datalen;
1183                 memcpy(new, fr, sizeof(*new));
1184                 iax_frame_wrap(new, &fr->af);
1185                 new->mallocd_datalen = mallocd_datalen;
1186                 new->data = NULL;
1187                 new->datalen = 0;
1188                 new->direction = DIRECTION_INGRESS;
1189                 new->retrans = -1;
1190         }
1191         return new;
1192 }
1193
1194 #define NEW_PREVENT     0
1195 #define NEW_ALLOW       1
1196 #define NEW_FORCE       2
1197
1198 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1199 {
1200         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1201                 (cur->addr.sin_port == sin->sin_port)) {
1202                 /* This is the main host */
1203                 if ((cur->peercallno == callno) ||
1204                         ((dcallno == cur->callno) && !cur->peercallno)) {
1205                         /* That's us.  Be sure we keep track of the peer call number */
1206                         return 1;
1207                 }
1208         }
1209         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1210             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1211                 /* We're transferring */
1212                 if (dcallno == cur->callno)
1213                         return 1;
1214         }
1215         return 0;
1216 }
1217
1218 static void update_max_trunk(void)
1219 {
1220         int max = TRUNK_CALL_START;
1221         int x;
1222         /* XXX Prolly don't need locks here XXX */
1223         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1224                 if (iaxs[x])
1225                         max = x + 1;
1226         }
1227         maxtrunkcall = max;
1228         if (option_debug && iaxdebug)
1229                 ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max);
1230 }
1231
1232 static void update_max_nontrunk(void)
1233 {
1234         int max = 1;
1235         int x;
1236         /* XXX Prolly don't need locks here XXX */
1237         for (x=1;x<TRUNK_CALL_START - 1; x++) {
1238                 if (iaxs[x])
1239                         max = x + 1;
1240         }
1241         maxnontrunkcall = max;
1242         if (option_debug && iaxdebug)
1243                 ast_log(LOG_DEBUG, "New max nontrunk callno is %d\n", max);
1244 }
1245
1246 static int make_trunk(unsigned short callno, int locked)
1247 {
1248         int x;
1249         int res= 0;
1250         struct timeval now;
1251         if (iaxs[callno]->oseqno) {
1252                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1253                 return -1;
1254         }
1255         if (callno & TRUNK_CALL_START) {
1256                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1257                 return -1;
1258         }
1259         gettimeofday(&now, NULL);
1260         for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1261                 ast_mutex_lock(&iaxsl[x]);
1262                 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1263                         iaxs[x] = iaxs[callno];
1264                         iaxs[x]->callno = x;
1265                         iaxs[callno] = NULL;
1266                         /* Update the two timers that should have been started */
1267                         if (iaxs[x]->pingid > -1)
1268                                 ast_sched_del(sched, iaxs[x]->pingid);
1269                         if (iaxs[x]->lagid > -1)
1270                                 ast_sched_del(sched, iaxs[x]->lagid);
1271                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1272                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1273                         if (locked)
1274                                 ast_mutex_unlock(&iaxsl[callno]);
1275                         res = x;
1276                         if (!locked)
1277                                 ast_mutex_unlock(&iaxsl[x]);
1278                         break;
1279                 }
1280                 ast_mutex_unlock(&iaxsl[x]);
1281         }
1282         if (x >= IAX_MAX_CALLS - 1) {
1283                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1284                 return -1;
1285         }
1286         if (option_debug)
1287                 ast_log(LOG_DEBUG, "Made call %d into trunk call %d\n", callno, x);
1288         /* We move this call from a non-trunked to a trunked call */
1289         update_max_trunk();
1290         update_max_nontrunk();
1291         return res;
1292 }
1293
1294 /*!
1295  * \todo XXX Note that this function contains a very expensive operation that
1296  * happens for *every* incoming media frame.  It iterates through every
1297  * possible call number, locking and unlocking each one, to try to match the
1298  * incoming frame to an active call.  Call numbers can be up to 2^15, 32768.
1299  * So, for an call with a local call number of 20000, every incoming audio
1300  * frame would require 20000 mutex lock and unlock operations.  Ouch.
1301  *
1302  * It's a shame that IAX2 media frames carry the source call number instead of
1303  * the destination call number.  If they did, this lookup wouldn't be needed.
1304  * However, it's too late to change that now.  Instead, we need to come up with
1305  * a better way of indexing active calls so that these frequent lookups are not
1306  * so expensive.
1307  */
1308 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1309 {
1310         int res = 0;
1311         int x;
1312         struct timeval now;
1313         char host[80];
1314         if (new <= NEW_ALLOW) {
1315                 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1316                         ast_mutex_lock(&iaxsl[x]);
1317                         if (iaxs[x]) {
1318                                 /* Look for an exact match */
1319                                 if (match(sin, callno, dcallno, iaxs[x])) {
1320                                         res = x;
1321                                 }
1322                         }
1323                         ast_mutex_unlock(&iaxsl[x]);
1324                 }
1325                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1326                         ast_mutex_lock(&iaxsl[x]);
1327                         if (iaxs[x]) {
1328                                 /* Look for an exact match */
1329                                 if (match(sin, callno, dcallno, iaxs[x])) {
1330                                         res = x;
1331                                 }
1332                         }
1333                         ast_mutex_unlock(&iaxsl[x]);
1334                 }
1335         }
1336         if ((res < 1) && (new >= NEW_ALLOW)) {
1337                 /* It may seem odd that we look through the peer list for a name for
1338                  * this *incoming* call.  Well, it is weird.  However, users don't
1339                  * have an IP address/port number that we can match against.  So,
1340                  * this is just checking for a peer that has that IP/port and
1341                  * assuming that we have a user of the same name.  This isn't always
1342                  * correct, but it will be changed if needed after authentication. */
1343                 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1344                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1345                 gettimeofday(&now, NULL);
1346                 for (x=1;x<TRUNK_CALL_START;x++) {
1347                         /* Find first unused call number that hasn't been used in a while */
1348                         ast_mutex_lock(&iaxsl[x]);
1349                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1350                         ast_mutex_unlock(&iaxsl[x]);
1351                 }
1352                 /* We've still got lock held if we found a spot */
1353                 if (x >= TRUNK_CALL_START) {
1354                         ast_log(LOG_WARNING, "No more space\n");
1355                         return 0;
1356                 }
1357                 iaxs[x] = new_iax(sin, lockpeer, host);
1358                 update_max_nontrunk();
1359                 if (iaxs[x]) {
1360                         if (option_debug && iaxdebug)
1361                                 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
1362                         iaxs[x]->sockfd = sockfd;
1363                         iaxs[x]->addr.sin_port = sin->sin_port;
1364                         iaxs[x]->addr.sin_family = sin->sin_family;
1365                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1366                         iaxs[x]->peercallno = callno;
1367                         iaxs[x]->callno = x;
1368                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1369                         iaxs[x]->expiry = min_reg_expire;
1370                         iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1371                         iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1372                         iaxs[x]->amaflags = amaflags;
1373                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1374                         
1375                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1376                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1377                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1378                 } else {
1379                         ast_log(LOG_WARNING, "Out of resources\n");
1380                         ast_mutex_unlock(&iaxsl[x]);
1381                         return 0;
1382                 }
1383                 ast_mutex_unlock(&iaxsl[x]);
1384                 res = x;
1385         }
1386         return res;
1387 }
1388
1389 static void iax2_frame_free(struct iax_frame *fr)
1390 {
1391         if (fr->retrans > -1)
1392                 ast_sched_del(sched, fr->retrans);
1393         iax_frame_free(fr);
1394 }
1395
1396 static int iax2_queue_frame(int callno, struct ast_frame *f)
1397 {
1398         /* Assumes lock for callno is already held... */
1399         for (;;) {
1400                 if (iaxs[callno] && iaxs[callno]->owner) {
1401                         if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1402                                 /* Avoid deadlock by pausing and trying again */
1403                                 ast_mutex_unlock(&iaxsl[callno]);
1404                                 usleep(1);
1405                                 ast_mutex_lock(&iaxsl[callno]);
1406                         } else {
1407                                 ast_queue_frame(iaxs[callno]->owner, f);
1408                                 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1409                                 break;
1410                         }
1411                 } else
1412                         break;
1413         }
1414         return 0;
1415 }
1416
1417 static void destroy_firmware(struct iax_firmware *cur)
1418 {
1419         /* Close firmware */
1420         if (cur->fwh) {
1421                 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1422         }
1423         close(cur->fd);
1424         free(cur);
1425 }
1426
1427 static int try_firmware(char *s)
1428 {
1429         struct stat stbuf;
1430         struct iax_firmware *cur = NULL;
1431         int ifd, fd, res, len, chunk;
1432         struct ast_iax2_firmware_header *fwh, fwh2;
1433         struct MD5Context md5;
1434         unsigned char sum[16], buf[1024];
1435         char *s2, *last;
1436
1437         if (!(s2 = alloca(strlen(s) + 100))) {
1438                 ast_log(LOG_WARNING, "Alloca failed!\n");
1439                 return -1;
1440         }
1441
1442         last = strrchr(s, '/');
1443         if (last)
1444                 last++;
1445         else
1446                 last = s;
1447
1448         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1449
1450         if ((res = stat(s, &stbuf) < 0)) {
1451                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1452                 return -1;
1453         }
1454
1455         /* Make sure it's not a directory */
1456         if (S_ISDIR(stbuf.st_mode))
1457                 return -1;
1458         ifd = open(s, O_RDONLY);
1459         if (ifd < 0) {
1460                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1461                 return -1;
1462         }
1463         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1464         if (fd < 0) {
1465                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1466                 close(ifd);
1467                 return -1;
1468         }
1469         /* Unlink our newly created file */
1470         unlink(s2);
1471         
1472         /* Now copy the firmware into it */
1473         len = stbuf.st_size;
1474         while(len) {
1475                 chunk = len;
1476                 if (chunk > sizeof(buf))
1477                         chunk = sizeof(buf);
1478                 res = read(ifd, buf, chunk);
1479                 if (res != chunk) {
1480                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1481                         close(ifd);
1482                         close(fd);
1483                         return -1;
1484                 }
1485                 res = write(fd, buf, chunk);
1486                 if (res != chunk) {
1487                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1488                         close(ifd);
1489                         close(fd);
1490                         return -1;
1491                 }
1492                 len -= chunk;
1493         }
1494         close(ifd);
1495         /* Return to the beginning */
1496         lseek(fd, 0, SEEK_SET);
1497         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1498                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1499                 close(fd);
1500                 return -1;
1501         }
1502         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1503                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1504                 close(fd);
1505                 return -1;
1506         }
1507         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1508                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1509                 close(fd);
1510                 return -1;
1511         }
1512         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1513                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1514                 close(fd);
1515                 return -1;
1516         }
1517         fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1518         if (fwh == (void *) -1) {
1519                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1520                 close(fd);
1521                 return -1;
1522         }
1523         MD5Init(&md5);
1524         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1525         MD5Final(sum, &md5);
1526         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1527                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1528                 munmap(fwh, stbuf.st_size);
1529                 close(fd);
1530                 return -1;
1531         }
1532
1533         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1534                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1535                         /* Found a candidate */
1536                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1537                                 /* The version we have on loaded is older, load this one instead */
1538                                 break;
1539                         /* This version is no newer than what we have.  Don't worry about it.
1540                            We'll consider it a proper load anyhow though */
1541                         munmap(fwh, stbuf.st_size);
1542                         close(fd);
1543                         return 0;
1544                 }
1545         }
1546         
1547         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1548                 cur->fd = -1;
1549                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1550         }
1551         
1552         if (cur) {
1553                 if (cur->fwh)
1554                         munmap(cur->fwh, cur->mmaplen);
1555                 if (cur->fd > -1)
1556                         close(cur->fd);
1557                 cur->fwh = fwh;
1558                 cur->fd = fd;
1559                 cur->mmaplen = stbuf.st_size;
1560                 cur->dead = 0;
1561         }
1562         
1563         return 0;
1564 }
1565
1566 static int iax_check_version(char *dev)
1567 {
1568         int res = 0;
1569         struct iax_firmware *cur = NULL;
1570
1571         if (ast_strlen_zero(dev))
1572                 return 0;
1573
1574         AST_LIST_LOCK(&firmwares);
1575         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1576                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1577                         res = ntohs(cur->fwh->version);
1578                         break;
1579                 }
1580         }
1581         AST_LIST_UNLOCK(&firmwares);
1582
1583         return res;
1584 }
1585
1586 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1587 {
1588         int res = -1;
1589         unsigned int bs = desc & 0xff;
1590         unsigned int start = (desc >> 8) & 0xffffff;
1591         unsigned int bytes;
1592         struct iax_firmware *cur;
1593
1594         if (ast_strlen_zero((char *)dev) || !bs)
1595                 return -1;
1596
1597         start *= bs;
1598         
1599         AST_LIST_LOCK(&firmwares);
1600         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1601                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1602                         continue;
1603                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1604                 if (start < ntohl(cur->fwh->datalen)) {
1605                         bytes = ntohl(cur->fwh->datalen) - start;
1606                         if (bytes > bs)
1607                                 bytes = bs;
1608                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1609                 } else {
1610                         bytes = 0;
1611                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1612                 }
1613                 if (bytes == bs)
1614                         res = 0;
1615                 else
1616                         res = 1;
1617                 break;
1618         }
1619         AST_LIST_UNLOCK(&firmwares);
1620
1621         return res;
1622 }
1623
1624
1625 static void reload_firmware(void)
1626 {
1627         struct iax_firmware *cur = NULL;
1628         DIR *fwd;
1629         struct dirent *de;
1630         char dir[256], fn[256];
1631
1632         AST_LIST_LOCK(&firmwares);
1633
1634         /* Mark all as dead */
1635         AST_LIST_TRAVERSE(&firmwares, cur, list)
1636                 cur->dead = 1;
1637
1638         /* Now that we have marked them dead... load new ones */
1639         snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1640         fwd = opendir(dir);
1641         if (fwd) {
1642                 while((de = readdir(fwd))) {
1643                         if (de->d_name[0] != '.') {
1644                                 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1645                                 if (!try_firmware(fn)) {
1646                                         if (option_verbose > 1)
1647                                                 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1648                                 }
1649                         }
1650                 }
1651                 closedir(fwd);
1652         } else 
1653                 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1654
1655         /* Clean up leftovers */
1656         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1657                 if (!cur->dead)
1658                         continue;
1659                 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1660                 destroy_firmware(cur);
1661         }
1662         AST_LIST_TRAVERSE_SAFE_END
1663
1664         AST_LIST_UNLOCK(&firmwares);
1665 }
1666
1667 static int __do_deliver(void *data)
1668 {
1669         /* Just deliver the packet by using queueing.  This is called by
1670           the IAX thread with the iaxsl lock held. */
1671         struct iax_frame *fr = data;
1672         fr->retrans = -1;
1673         fr->af.has_timing_info = 0;
1674         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1675                 iax2_queue_frame(fr->callno, &fr->af);
1676         /* Free our iax frame */
1677         iax2_frame_free(fr);
1678         /* And don't run again */
1679         return 0;
1680 }
1681
1682 static int handle_error(void)
1683 {
1684         /* XXX Ideally we should figure out why an error occurred and then abort those
1685            rather than continuing to try.  Unfortunately, the published interface does
1686            not seem to work XXX */
1687 #if 0
1688         struct sockaddr_in *sin;
1689         int res;
1690         struct msghdr m;
1691         struct sock_extended_err e;
1692         m.msg_name = NULL;
1693         m.msg_namelen = 0;
1694         m.msg_iov = NULL;
1695         m.msg_control = &e;
1696         m.msg_controllen = sizeof(e);
1697         m.msg_flags = 0;
1698         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1699         if (res < 0)
1700                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1701         else {
1702                 if (m.msg_controllen) {
1703                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1704                         if (sin) 
1705                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1706                         else
1707                                 ast_log(LOG_WARNING, "No address detected??\n");
1708                 } else {
1709                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1710                 }
1711         }
1712 #endif
1713         return 0;
1714 }
1715
1716 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1717 {
1718         int res;
1719         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1720                                         sizeof(*sin));
1721         if (res < 0) {
1722                 if (option_debug)
1723                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1724                 handle_error();
1725         } else
1726                 res = 0;
1727         return res;
1728 }
1729
1730 static int send_packet(struct iax_frame *f)
1731 {
1732         int res;
1733         int callno = f->callno;
1734
1735         /* Don't send if there was an error, but return error instead */
1736         if (!callno || !iaxs[callno] || iaxs[callno]->error)
1737             return -1;
1738         
1739         /* Called with iaxsl held */
1740         if (option_debug > 2 && iaxdebug)
1741                 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));
1742         if (f->transfer) {
1743                 if (iaxdebug)
1744                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1745                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1746                                         sizeof(iaxs[callno]->transfer));
1747         } else {
1748                 if (iaxdebug)
1749                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1750                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1751                                         sizeof(iaxs[callno]->addr));
1752         }
1753         if (res < 0) {
1754                 if (option_debug && iaxdebug)
1755                         ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1756                 handle_error();
1757         } else
1758                 res = 0;
1759         return res;
1760 }
1761
1762 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1763 {
1764         struct iax2_user *user = NULL;
1765
1766         /* Decrement AUTHREQ count if needed */
1767         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1768                 AST_LIST_LOCK(&users);
1769                 AST_LIST_TRAVERSE(&users, user, entry) {
1770                         if (!strcmp(user->name, pvt->username)) {
1771                                 user->curauthreq--;
1772                                 break;
1773                         }
1774                 }
1775                 AST_LIST_UNLOCK(&users);
1776                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1777         }
1778         /* No more pings or lagrq's */
1779         if (pvt->pingid > -1)
1780                 ast_sched_del(sched, pvt->pingid);
1781         pvt->pingid = -1;
1782         if (pvt->lagid > -1)
1783                 ast_sched_del(sched, pvt->lagid);
1784         pvt->lagid = -1;
1785         if (pvt->autoid > -1)
1786                 ast_sched_del(sched, pvt->autoid);
1787         pvt->autoid = -1;
1788         if (pvt->authid > -1)
1789                 ast_sched_del(sched, pvt->authid);
1790         pvt->authid = -1;
1791         if (pvt->initid > -1)
1792                 ast_sched_del(sched, pvt->initid);
1793         pvt->initid = -1;
1794         if (pvt->jbid > -1)
1795                 ast_sched_del(sched, pvt->jbid);
1796         pvt->jbid = -1;
1797 }
1798
1799 static int iax2_predestroy(int callno)
1800 {
1801         struct ast_channel *c = NULL;
1802         struct chan_iax2_pvt *pvt = iaxs[callno];
1803
1804         if (!pvt)
1805                 return -1;
1806
1807         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1808                 iax2_destroy_helper(pvt);
1809                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1810         }
1811
1812         if ((c = pvt->owner)) {
1813                 c->_softhangup |= AST_SOFTHANGUP_DEV;
1814                 c->tech_pvt = NULL;
1815                 ast_queue_hangup(c);
1816                 pvt->owner = NULL;
1817                 ast_module_unref(ast_module_info->self);
1818         }
1819
1820         return 0;
1821 }
1822
1823 static void iax2_destroy(int callno)
1824 {
1825         struct chan_iax2_pvt *pvt = NULL;
1826         struct iax_frame *cur = NULL;
1827         struct ast_channel *owner = NULL;
1828
1829 retry:
1830         pvt = iaxs[callno];
1831         gettimeofday(&lastused[callno], NULL);
1832         
1833         owner = pvt ? pvt->owner : NULL;
1834
1835         if (owner) {
1836                 if (ast_mutex_trylock(&owner->lock)) {
1837                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1838                         ast_mutex_unlock(&iaxsl[callno]);
1839                         usleep(1);
1840                         ast_mutex_lock(&iaxsl[callno]);
1841                         goto retry;
1842                 }
1843         }
1844         if (!owner)
1845                 iaxs[callno] = NULL;
1846         if (pvt) {
1847                 if (!owner)
1848                         pvt->owner = NULL;
1849                 iax2_destroy_helper(pvt);
1850
1851                 /* Already gone */
1852                 ast_set_flag(pvt, IAX_ALREADYGONE);     
1853
1854                 if (owner) {
1855                         /* If there's an owner, prod it to give up */
1856                         owner->_softhangup |= AST_SOFTHANGUP_DEV;
1857                         ast_queue_hangup(owner);
1858                 }
1859
1860                 AST_LIST_LOCK(&queue);
1861                 AST_LIST_TRAVERSE(&queue, cur, list) {
1862                         /* Cancel any pending transmissions */
1863                         if (cur->callno == pvt->callno) 
1864                                 cur->retries = -1;
1865                 }
1866                 AST_LIST_UNLOCK(&queue);
1867
1868                 if (pvt->reg)
1869                         pvt->reg->callno = 0;
1870                 if (!owner) {
1871                         jb_frame frame;
1872                         if (pvt->vars) {
1873                             ast_variables_destroy(pvt->vars);
1874                             pvt->vars = NULL;
1875                         }
1876
1877                         while (jb_getall(pvt->jb, &frame) == JB_OK)
1878                                 iax2_frame_free(frame.data);
1879                         jb_destroy(pvt->jb);
1880                         /* gotta free up the stringfields */
1881                         ast_string_field_free_pools(pvt);
1882                         free(pvt);
1883                 }
1884         }
1885         if (owner) {
1886                 ast_mutex_unlock(&owner->lock);
1887         }
1888         if (callno & 0x4000)
1889                 update_max_trunk();
1890 }
1891
1892 static int update_packet(struct iax_frame *f)
1893 {
1894         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1895         struct ast_iax2_full_hdr *fh = f->data;
1896         /* Mark this as a retransmission */
1897         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1898         /* Update iseqno */
1899         f->iseqno = iaxs[f->callno]->iseqno;
1900         fh->iseqno = f->iseqno;
1901         return 0;
1902 }
1903
1904 static int attempt_transmit(void *data);
1905 static void __attempt_transmit(void *data)
1906 {
1907         /* Attempt to transmit the frame to the remote peer...
1908            Called without iaxsl held. */
1909         struct iax_frame *f = data;
1910         int freeme=0;
1911         int callno = f->callno;
1912         /* Make sure this call is still active */
1913         if (callno) 
1914                 ast_mutex_lock(&iaxsl[callno]);
1915         if (callno && iaxs[callno]) {
1916                 if ((f->retries < 0) /* Already ACK'd */ ||
1917                     (f->retries >= max_retries) /* Too many attempts */) {
1918                                 /* Record an error if we've transmitted too many times */
1919                                 if (f->retries >= max_retries) {
1920                                         if (f->transfer) {
1921                                                 /* Transfer timeout */
1922                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1923                                         } else if (f->final) {
1924                                                 if (f->final) 
1925                                                         iax2_destroy(callno);
1926                                         } else {
1927                                                 if (iaxs[callno]->owner)
1928                                                         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);
1929                                                 iaxs[callno]->error = ETIMEDOUT;
1930                                                 if (iaxs[callno]->owner) {
1931                                                         struct ast_frame fr = { 0, };
1932                                                         /* Hangup the fd */
1933                                                         fr.frametype = AST_FRAME_CONTROL;
1934                                                         fr.subclass = AST_CONTROL_HANGUP;
1935                                                         iax2_queue_frame(callno, &fr);
1936                                                         /* Remember, owner could disappear */
1937                                                         if (iaxs[callno]->owner)
1938                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1939                                                 } else {
1940                                                         if (iaxs[callno]->reg) {
1941                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
1942                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
1943                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1944                                                         }
1945                                                         iax2_destroy(callno);
1946                                                 }
1947                                         }
1948
1949                                 }
1950                                 freeme++;
1951                 } else {
1952                         /* Update it if it needs it */
1953                         update_packet(f);
1954                         /* Attempt transmission */
1955                         send_packet(f);
1956                         f->retries++;
1957                         /* Try again later after 10 times as long */
1958                         f->retrytime *= 10;
1959                         if (f->retrytime > MAX_RETRY_TIME)
1960                                 f->retrytime = MAX_RETRY_TIME;
1961                         /* Transfer messages max out at one second */
1962                         if (f->transfer && (f->retrytime > 1000))
1963                                 f->retrytime = 1000;
1964                         f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1965                 }
1966         } else {
1967                 /* Make sure it gets freed */
1968                 f->retries = -1;
1969                 freeme++;
1970         }
1971         if (callno)
1972                 ast_mutex_unlock(&iaxsl[callno]);
1973         /* Do not try again */
1974         if (freeme) {
1975                 /* Don't attempt delivery, just remove it from the queue */
1976                 AST_LIST_LOCK(&queue);
1977                 AST_LIST_REMOVE(&queue, f, list);
1978                 AST_LIST_UNLOCK(&queue);
1979                 f->retrans = -1;
1980                 /* Free the IAX frame */
1981                 iax2_frame_free(f);
1982         }
1983 }
1984
1985 static int attempt_transmit(void *data)
1986 {
1987 #ifdef SCHED_MULTITHREADED
1988         if (schedule_action(__attempt_transmit, data))
1989 #endif          
1990                 __attempt_transmit(data);
1991         return 0;
1992 }
1993
1994 static int iax2_prune_realtime(int fd, int argc, char *argv[])
1995 {
1996         struct iax2_peer *peer;
1997
1998         if (argc != 4)
1999         return RESULT_SHOWUSAGE;
2000         if (!strcmp(argv[3],"all")) {
2001                 reload_config();
2002                 ast_cli(fd, "OK cache is flushed.\n");
2003         } else if ((peer = find_peer(argv[3], 0))) {
2004                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2005                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2006                         expire_registry((void*)peer->name);
2007                         ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
2008                 } else {
2009                         ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
2010                 }
2011         } else {
2012                 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
2013         }
2014         
2015         return RESULT_SUCCESS;
2016 }
2017
2018 static int iax2_test_losspct(int fd, int argc, char *argv[])
2019 {
2020        if (argc != 4)
2021                return RESULT_SHOWUSAGE;
2022
2023        test_losspct = atoi(argv[3]);
2024
2025        return RESULT_SUCCESS;
2026 }
2027
2028 #ifdef IAXTESTS
2029 static int iax2_test_late(int fd, int argc, char *argv[])
2030 {
2031         if (argc != 4)
2032                 return RESULT_SHOWUSAGE;
2033
2034         test_late = atoi(argv[3]);
2035
2036         return RESULT_SUCCESS;
2037 }
2038
2039 static int iax2_test_resync(int fd, int argc, char *argv[])
2040 {
2041         if (argc != 4)
2042                 return RESULT_SHOWUSAGE;
2043
2044         test_resync = atoi(argv[3]);
2045
2046         return RESULT_SUCCESS;
2047 }
2048
2049 static int iax2_test_jitter(int fd, int argc, char *argv[])
2050 {
2051         if (argc < 4 || argc > 5)
2052                 return RESULT_SHOWUSAGE;
2053
2054         test_jit = atoi(argv[3]);
2055         if (argc == 5) 
2056                 test_jitpct = atoi(argv[4]);
2057
2058         return RESULT_SUCCESS;
2059 }
2060 #endif /* IAXTESTS */
2061
2062 /*! \brief  peer_status: Report Peer status in character string */
2063 /*      returns 1 if peer is online, -1 if unmonitored */
2064 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2065 {
2066         int res = 0;
2067         if (peer->maxms) {
2068                 if (peer->lastms < 0) {
2069                         ast_copy_string(status, "UNREACHABLE", statuslen);
2070                 } else if (peer->lastms > peer->maxms) {
2071                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2072                         res = 1;
2073                 } else if (peer->lastms) {
2074                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2075                         res = 1;
2076                 } else {
2077                         ast_copy_string(status, "UNKNOWN", statuslen);
2078                 }
2079         } else { 
2080                 ast_copy_string(status, "Unmonitored", statuslen);
2081                 res = -1;
2082         }
2083         return res;
2084 }
2085
2086 /*! \brief Show one peer in detail */
2087 static int iax2_show_peer(int fd, int argc, char *argv[])
2088 {
2089         char status[30];
2090         char cbuf[256];
2091         struct iax2_peer *peer;
2092         char codec_buf[512];
2093         int x = 0, codec = 0, load_realtime = 0;
2094
2095         if (argc < 4)
2096                 return RESULT_SHOWUSAGE;
2097
2098         load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2099
2100         peer = find_peer(argv[3], load_realtime);
2101         if (peer) {
2102                 ast_cli(fd,"\n\n");
2103                 ast_cli(fd, "  * Name       : %s\n", peer->name);
2104                 ast_cli(fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2105                 ast_cli(fd, "  Context      : %s\n", peer->context);
2106                 ast_cli(fd, "  Mailbox      : %s\n", peer->mailbox);
2107                 ast_cli(fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2108                 ast_cli(fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2109                 ast_cli(fd, "  Expire       : %d\n", peer->expire);
2110                 ast_cli(fd, "  ACL          : %s\n", (peer->ha?"Yes":"No"));
2111                 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));
2112                 ast_cli(fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2113                 ast_cli(fd, "  Username     : %s\n", peer->username);
2114                 ast_cli(fd, "  Codecs       : ");
2115                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2116                 ast_cli(fd, "%s\n", codec_buf);
2117
2118                 ast_cli(fd, "  Codec Order  : (");
2119                 for(x = 0; x < 32 ; x++) {
2120                         codec = ast_codec_pref_index(&peer->prefs,x);
2121                         if(!codec)
2122                                 break;
2123                         ast_cli(fd, "%s", ast_getformatname(codec));
2124                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2125                                 ast_cli(fd, "|");
2126                 }
2127
2128                 if (!x)
2129                         ast_cli(fd, "none");
2130                 ast_cli(fd, ")\n");
2131
2132                 ast_cli(fd, "  Status       : ");
2133                 peer_status(peer, status, sizeof(status));      
2134                 ast_cli(fd, "%s\n",status);
2135                 ast_cli(fd, "  Qualify      : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2136                 ast_cli(fd,"\n");
2137                 if (ast_test_flag(peer, IAX_TEMPONLY))
2138                         destroy_peer(peer);
2139         } else {
2140                 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2141                 ast_cli(fd,"\n");
2142         }
2143
2144         return RESULT_SUCCESS;
2145 }
2146
2147 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2148 {
2149         int which = 0;
2150         struct iax2_peer *p = NULL;
2151         char *res = NULL;
2152         int wordlen = strlen(word);
2153
2154         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2155         if (pos == 3) {
2156                 AST_LIST_LOCK(&peers);
2157                 AST_LIST_TRAVERSE(&peers, p, entry) {
2158                         if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2159                                 res = ast_strdup(p->name);
2160                                 break;
2161                         }
2162                 }
2163                 AST_LIST_UNLOCK(&peers);
2164         }
2165
2166         return res;
2167 }
2168
2169 static int iax2_show_stats(int fd, int argc, char *argv[])
2170 {
2171         struct iax_frame *cur;
2172         int cnt = 0, dead=0, final=0;
2173
2174         if (argc != 3)
2175                 return RESULT_SHOWUSAGE;
2176
2177         AST_LIST_LOCK(&queue);
2178         AST_LIST_TRAVERSE(&queue, cur, list) {
2179                 if (cur->retries < 0)
2180                         dead++;
2181                 if (cur->final)
2182                         final++;
2183                 cnt++;
2184         }
2185         AST_LIST_UNLOCK(&queue);
2186
2187         ast_cli(fd, "    IAX Statistics\n");
2188         ast_cli(fd, "---------------------\n");
2189         ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2190         ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2191                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2192
2193         ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2194
2195         trunk_timed = trunk_untimed = 0;
2196         if (trunk_maxmtu > trunk_nmaxmtu)
2197                 trunk_nmaxmtu = trunk_maxmtu;
2198         
2199         return RESULT_SUCCESS;
2200 }
2201
2202 /*! \brief Set trunk MTU from CLI */
2203 static int iax2_set_mtu(int fd, int argc, char *argv[])
2204 {
2205         int mtuv;
2206
2207         if (argc != 4)
2208                 return RESULT_SHOWUSAGE; 
2209         if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0) 
2210                 mtuv = MAX_TRUNK_MTU; 
2211         else                                         
2212                 mtuv = atoi(argv[3]); 
2213
2214         if (mtuv == 0) {
2215                 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2216                 global_max_trunk_mtu = 0; 
2217                 return RESULT_SUCCESS; 
2218         }
2219         if (mtuv < 172 || mtuv > 4000) {
2220                 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n"); 
2221                 return RESULT_SHOWUSAGE; 
2222         }
2223         ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2224         global_max_trunk_mtu = mtuv; 
2225         return RESULT_SUCCESS;
2226 }
2227
2228 static int iax2_show_cache(int fd, int argc, char *argv[])
2229 {
2230         struct iax2_dpcache *dp = NULL;
2231         char tmp[1024], *pc = NULL;
2232         int s, x, y;
2233         struct timeval tv;
2234
2235         gettimeofday(&tv, NULL);
2236
2237         AST_LIST_LOCK(&dpcache);
2238
2239         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2240
2241         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2242                 s = dp->expiry.tv_sec - tv.tv_sec;
2243                 tmp[0] = '\0';
2244                 if (dp->flags & CACHE_FLAG_EXISTS)
2245                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2246                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2247                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2248                 if (dp->flags & CACHE_FLAG_CANEXIST)
2249                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2250                 if (dp->flags & CACHE_FLAG_PENDING)
2251                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2252                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2253                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2254                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2255                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2256                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2257                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2258                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2259                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2260                 /* Trim trailing pipe */
2261                 if (!ast_strlen_zero(tmp))
2262                         tmp[strlen(tmp) - 1] = '\0';
2263                 else
2264                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2265                 y=0;
2266                 pc = strchr(dp->peercontext, '@');
2267                 if (!pc)
2268                         pc = dp->peercontext;
2269                 else
2270                         pc++;
2271                 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2272                         if (dp->waiters[x] > -1)
2273                                 y++;
2274                 if (s > 0)
2275                         ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2276                 else
2277                         ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2278         }
2279
2280         AST_LIST_LOCK(&dpcache);
2281
2282         return RESULT_SUCCESS;
2283 }
2284
2285 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2286
2287 static void unwrap_timestamp(struct iax_frame *fr)
2288 {
2289         int x;
2290
2291         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2292                 x = fr->ts - iaxs[fr->callno]->last;
2293                 if (x < -50000) {
2294                         /* Sudden big jump backwards in timestamp:
2295                            What likely happened here is that miniframe timestamp has circled but we haven't
2296                            gotten the update from the main packet.  We'll just pretend that we did, and
2297                            update the timestamp appropriately. */
2298                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2299                         if (option_debug && iaxdebug)
2300                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed forward timestamp\n");
2301                 }
2302                 if (x > 50000) {
2303                         /* Sudden apparent big jump forwards in timestamp:
2304                            What's likely happened is this is an old miniframe belonging to the previous
2305                            top-16-bit timestamp that has turned up out of order.
2306                            Adjust the timestamp appropriately. */
2307                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2308                         if (option_debug && iaxdebug)
2309                                 ast_log(LOG_DEBUG, "schedule_delivery: pushed back timestamp\n");
2310                 }
2311         }
2312 }
2313
2314 static int get_from_jb(void *p);
2315
2316 static void update_jbsched(struct chan_iax2_pvt *pvt)
2317 {
2318         int when;
2319         
2320         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2321         
2322         when = jb_next(pvt->jb) - when;
2323         
2324         if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2325         
2326         if(when <= 0) {
2327                 /* XXX should really just empty until when > 0.. */
2328                 when = 1;
2329         }
2330         
2331         pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2332         
2333         /* Signal scheduler thread */
2334         signal_condition(&sched_lock, &sched_cond);
2335 }
2336
2337 static void __get_from_jb(void *p) 
2338 {
2339         int callno = PTR_TO_CALLNO(p);
2340         struct chan_iax2_pvt *pvt = NULL;
2341         struct iax_frame *fr;
2342         jb_frame frame;
2343         int ret;
2344         long now;
2345         long next;
2346         struct timeval tv;
2347         
2348         /* Make sure we have a valid private structure before going on */
2349         ast_mutex_lock(&iaxsl[callno]);
2350         pvt = iaxs[callno];
2351         if (!pvt) {
2352                 /* No go! */
2353                 ast_mutex_unlock(&iaxsl[callno]);
2354                 return;
2355         }
2356
2357         pvt->jbid = -1;
2358         
2359         gettimeofday(&tv,NULL);
2360         /* round up a millisecond since ast_sched_runq does; */
2361         /* prevents us from spinning while waiting for our now */
2362         /* to catch up with runq's now */
2363         tv.tv_usec += 1000;
2364         
2365         now = ast_tvdiff_ms(tv, pvt->rxcore);
2366         
2367         if(now >= (next = jb_next(pvt->jb))) {
2368                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2369                 switch(ret) {
2370                 case JB_OK:
2371                         fr = frame.data;
2372                         __do_deliver(fr);
2373                         break;
2374                 case JB_INTERP:
2375                 {
2376                         struct ast_frame af = { 0, };
2377                         
2378                         /* create an interpolation frame */
2379                         af.frametype = AST_FRAME_VOICE;
2380                         af.subclass = pvt->voiceformat;
2381                         af.samples  = frame.ms * 8;
2382                         af.src  = "IAX2 JB interpolation";
2383                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2384                         af.offset = AST_FRIENDLY_OFFSET;
2385                         
2386                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2387                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2388                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE))
2389                                 iax2_queue_frame(callno, &af);
2390                 }
2391                 break;
2392                 case JB_DROP:
2393                         iax2_frame_free(frame.data);
2394                         break;
2395                 case JB_NOFRAME:
2396                 case JB_EMPTY:
2397                         /* do nothing */
2398                         break;
2399                 default:
2400                         /* shouldn't happen */
2401                         break;
2402                 }
2403         }
2404         update_jbsched(pvt);
2405         ast_mutex_unlock(&iaxsl[callno]);
2406 }
2407
2408 static int get_from_jb(void *data)
2409 {
2410 #ifdef SCHED_MULTITHREADED
2411         if (schedule_action(__get_from_jb, data))
2412 #endif          
2413                 __get_from_jb(data);
2414         return 0;
2415 }
2416
2417 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2418 {
2419         int type, len;
2420         int ret;
2421         int needfree = 0;
2422
2423         /* Attempt to recover wrapped timestamps */
2424         unwrap_timestamp(fr);
2425         
2426
2427         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2428         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2429                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2430         else {
2431 #if 0
2432                 if (option_debug)
2433                         ast_log(LOG_DEBUG, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2434 #endif
2435                 fr->af.delivery = ast_tv(0,0);
2436         }
2437
2438         type = JB_TYPE_CONTROL;
2439         len = 0;
2440
2441         if(fr->af.frametype == AST_FRAME_VOICE) {
2442                 type = JB_TYPE_VOICE;
2443                 len = ast_codec_get_samples(&fr->af) / 8;
2444         } else if(fr->af.frametype == AST_FRAME_CNG) {
2445                 type = JB_TYPE_SILENCE;
2446         }
2447
2448         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2449                 if (tsout)
2450                         *tsout = fr->ts;
2451                 __do_deliver(fr);
2452                 return -1;
2453         }
2454
2455         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2456          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2457         if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2458             iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2459             (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2460                 jb_frame frame;
2461
2462                 /* deliver any frames in the jb */
2463                 while(jb_getall(iaxs[fr->callno]->jb,&frame) == JB_OK)
2464                         __do_deliver(frame.data);
2465
2466                 jb_reset(iaxs[fr->callno]->jb);
2467
2468                 if (iaxs[fr->callno]->jbid > -1)
2469                         ast_sched_del(sched, iaxs[fr->callno]->jbid);
2470
2471                 iaxs[fr->callno]->jbid = -1;
2472
2473                 /* deliver this frame now */
2474                 if (tsout)
2475                         *tsout = fr->ts;
2476                 __do_deliver(fr);
2477                 return -1;
2478         }
2479
2480         /* insert into jitterbuffer */
2481         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2482         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2483                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2484         if (ret == JB_DROP) {
2485                 needfree++;
2486         } else if (ret == JB_SCHED) {
2487                 update_jbsched(iaxs[fr->callno]);
2488         }
2489         if (tsout)
2490                 *tsout = fr->ts;
2491         if (needfree) {
2492                 /* Free our iax frame */
2493                 iax2_frame_free(fr);
2494                 return -1;
2495         }
2496         return 0;
2497 }
2498
2499 static int iax2_transmit(struct iax_frame *fr)
2500 {
2501         /* Lock the queue and place this packet at the end */
2502         /* By setting this to 0, the network thread will send it for us, and
2503            queue retransmission if necessary */
2504         fr->sentyet = 0;
2505         AST_LIST_LOCK(&queue);
2506         AST_LIST_INSERT_TAIL(&queue, fr, list);
2507         AST_LIST_UNLOCK(&queue);
2508         /* Wake up the network and scheduler thread */
2509         pthread_kill(netthreadid, SIGURG);
2510         signal_condition(&sched_lock, &sched_cond);
2511         return 0;
2512 }
2513
2514
2515
2516 static int iax2_digit_begin(struct ast_channel *c, char digit)
2517 {
2518         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2519 }
2520
2521 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2522 {
2523         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2524 }
2525
2526 static int iax2_sendtext(struct ast_channel *c, const char *text)
2527 {
2528         
2529         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2530                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2531 }
2532
2533 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2534 {
2535         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2536 }
2537
2538 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2539 {
2540         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2541 }
2542
2543 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2544 {
2545         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2546         ast_mutex_lock(&iaxsl[callno]);
2547         if (iaxs[callno])
2548                 iaxs[callno]->owner = newchan;
2549         else
2550                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2551         ast_mutex_unlock(&iaxsl[callno]);
2552         return 0;
2553 }
2554
2555 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2556 {
2557         struct ast_variable *var;
2558         struct ast_variable *tmp;
2559         struct iax2_peer *peer=NULL;
2560         time_t regseconds = 0, nowtime;
2561         int dynamic=0;
2562
2563         if (peername)
2564                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2565         else {
2566                 char porta[25];
2567                 sprintf(porta, "%d", ntohs(sin->sin_port));
2568                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2569                 if (var) {
2570                         /* We'll need the peer name in order to build the structure! */
2571                         for (tmp = var; tmp; tmp = tmp->next) {
2572                                 if (!strcasecmp(tmp->name, "name"))
2573                                         peername = tmp->value;
2574                         }
2575                 }
2576         }
2577         if (!var)
2578                 return NULL;
2579
2580         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2581         
2582         if (!peer) {
2583                 ast_variables_destroy(var);
2584                 return NULL;
2585         }
2586
2587         for (tmp = var; tmp; tmp = tmp->next) {
2588                 /* Make sure it's not a user only... */
2589                 if (!strcasecmp(tmp->name, "type")) {
2590                         if (strcasecmp(tmp->value, "friend") &&
2591                             strcasecmp(tmp->value, "peer")) {
2592                                 /* Whoops, we weren't supposed to exist! */
2593                                 destroy_peer(peer);
2594                                 peer = NULL;
2595                                 break;
2596                         } 
2597                 } else if (!strcasecmp(tmp->name, "regseconds")) {
2598                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
2599                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2600                         inet_aton(tmp->value, &(peer->addr.sin_addr));
2601                 } else if (!strcasecmp(tmp->name, "port")) {
2602                         peer->addr.sin_port = htons(atoi(tmp->value));
2603                 } else if (!strcasecmp(tmp->name, "host")) {
2604                         if (!strcasecmp(tmp->value, "dynamic"))
2605                                 dynamic = 1;
2606                 }
2607         }
2608
2609         ast_variables_destroy(var);
2610
2611         if (!peer)
2612                 return NULL;
2613
2614         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2615                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2616                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2617                         if (peer->expire > -1)
2618                                 ast_sched_del(sched, peer->expire);
2619                         peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2620                 }
2621                 AST_LIST_LOCK(&peers);
2622                 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2623                 AST_LIST_UNLOCK(&peers);
2624                 if (ast_test_flag(peer, IAX_DYNAMIC))
2625                         reg_source_db(peer);
2626         } else {
2627                 ast_set_flag(peer, IAX_TEMPONLY);       
2628         }
2629
2630         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2631                 time(&nowtime);
2632                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2633                         memset(&peer->addr, 0, sizeof(peer->addr));
2634                         realtime_update_peer(peer->name, &peer->addr, 0);
2635                         if (option_debug)
2636                                 ast_log(LOG_DEBUG, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2637                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2638                 }
2639                 else {
2640                         if (option_debug)
2641                                 ast_log(LOG_DEBUG, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2642                                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2643                 }
2644         }
2645
2646         return peer;
2647 }
2648
2649 static struct iax2_user *realtime_user(const char *username)
2650 {
2651         struct ast_variable *var;
2652         struct ast_variable *tmp;
2653         struct iax2_user *user=NULL;
2654
2655         var = ast_load_realtime("iaxusers", "name", username, NULL);
2656         if (!var)
2657                 return NULL;
2658
2659         tmp = var;
2660         while(tmp) {
2661                 /* Make sure it's not a peer only... */
2662                 if (!strcasecmp(tmp->name, "type")) {
2663                         if (strcasecmp(tmp->value, "friend") &&
2664                             strcasecmp(tmp->value, "user")) {
2665                                 return NULL;
2666                         } 
2667                 }
2668                 tmp = tmp->next;
2669         }
2670
2671         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2672
2673         ast_variables_destroy(var);
2674
2675         if (!user)
2676                 return NULL;
2677
2678         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2679                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2680                 AST_LIST_LOCK(&users);
2681                 AST_LIST_INSERT_HEAD(&users, user, entry);
2682                 AST_LIST_UNLOCK(&users);
2683         } else {
2684                 ast_set_flag(user, IAX_TEMPONLY);       
2685         }
2686
2687         return user;
2688 }
2689
2690 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2691 {
2692         char port[10];
2693         char regseconds[20];
2694         
2695         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2696         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2697         ast_update_realtime("iaxpeers", "name", peername, 
2698                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
2699                 "regseconds", regseconds, NULL);
2700 }
2701
2702 struct create_addr_info {
2703         int capability;
2704         unsigned int flags;
2705         int maxtime;
2706         int encmethods;
2707         int found;
2708         int sockfd;
2709         int adsi;
2710         char username[80];
2711         char secret[80];
2712         char outkey[80];
2713         char timezone[80];
2714         char prefs[32];
2715         char context[AST_MAX_CONTEXT];
2716         char peercontext[AST_MAX_CONTEXT];
2717         char mohinterpret[MAX_MUSICCLASS];
2718         char mohsuggest[MAX_MUSICCLASS];
2719 };
2720
2721 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2722 {
2723         struct iax2_peer *peer;
2724
2725         ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2726         cai->sockfd = defaultsockfd;
2727         cai->maxtime = 0;
2728         sin->sin_family = AF_INET;
2729
2730         if (!(peer = find_peer(peername, 1))) {
2731                 cai->found = 0;
2732                 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
2733                         ast_log(LOG_WARNING, "No such host: %s\n", peername);
2734                         return -1;
2735                 }
2736                 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2737                 /* use global iax prefs for unknown peer/user */
2738                 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2739                 return 0;
2740         }
2741
2742         cai->found = 1;
2743         
2744         /* if the peer has no address (current or default), return failure */
2745         if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2746                 if (ast_test_flag(peer, IAX_TEMPONLY))
2747                         destroy_peer(peer);
2748                 return -1;
2749         }
2750
2751         /* if the peer is being monitored and is currently unreachable, return failure */
2752         if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2753                 if (ast_test_flag(peer, IAX_TEMPONLY))
2754                         destroy_peer(peer);
2755                 return -1;
2756         }
2757
2758         ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2759         cai->maxtime = peer->maxms;
2760         cai->capability = peer->capability;
2761         cai->encmethods = peer->encmethods;
2762         cai->sockfd = peer->sockfd;
2763         cai->adsi = peer->adsi;
2764         ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2765         ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2766         ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2767         ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2768         ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2769         ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2770         ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2771         ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2772         if (ast_strlen_zero(peer->dbsecret)) {
2773                 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2774         } else {
2775                 char *family;
2776                 char *key = NULL;
2777
2778                 family = ast_strdupa(peer->dbsecret);
2779                 key = strchr(family, '/');
2780                 if (key)
2781                         *key++ = '\0';
2782                 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2783                         ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2784                         if (ast_test_flag(peer, IAX_TEMPONLY))
2785                                 destroy_peer(peer);
2786                         return -1;
2787                 }
2788         }
2789
2790         if (peer->addr.sin_addr.s_addr) {
2791                 sin->sin_addr = peer->addr.sin_addr;
2792                 sin->sin_port = peer->addr.sin_port;
2793         } else {
2794                 sin->sin_addr = peer->defaddr.sin_addr;
2795                 sin->sin_port = peer->defaddr.sin_port;
2796         }
2797
2798         if (ast_test_flag(peer, IAX_TEMPONLY))
2799                 destroy_peer(peer);
2800
2801         return 0;
2802 }
2803
2804 static void __auto_congest(void *nothing)
2805 {
2806         int callno = PTR_TO_CALLNO(nothing);
2807         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2808         ast_mutex_lock(&iaxsl[callno]);
2809         if (iaxs[callno]) {
2810                 iaxs[callno]->initid = -1;
2811                 iax2_queue_frame(callno, &f);
2812                 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2813         }
2814         ast_mutex_unlock(&iaxsl[callno]);
2815 }
2816
2817 static int auto_congest(void *data)
2818 {
2819 #ifdef SCHED_MULTITHREADED
2820         if (schedule_action(__auto_congest, data))
2821 #endif          
2822                 __auto_congest(data);
2823         return 0;
2824 }
2825
2826 static unsigned int iax2_datetime(const char *tz)
2827 {
2828         time_t t;
2829         struct tm tm;
2830         unsigned int tmp;
2831         time(&t);
2832         localtime_r(&t, &tm);
2833         if (!ast_strlen_zero(tz))
2834                 ast_localtime(&t, &tm, tz);
2835         tmp  = (tm.tm_sec >> 1) & 0x1f;                 /* 5 bits of seconds */
2836         tmp |= (tm.tm_min & 0x3f) << 5;                 /* 6 bits of minutes */
2837         tmp |= (tm.tm_hour & 0x1f) << 11;               /* 5 bits of hours */
2838         tmp |= (tm.tm_mday & 0x1f) << 16;               /* 5 bits of day of month */
2839         tmp |= ((tm.tm_mon + 1) & 0xf) << 21;           /* 4 bits of month */
2840         tmp |= ((tm.tm_year - 100) & 0x7f) << 25;       /* 7 bits of year */
2841         return tmp;
2842 }
2843
2844 struct parsed_dial_string {
2845         char *username;
2846         char *password;
2847         char *key;
2848         char *peer;
2849         char *port;
2850         char *exten;
2851         char *context;
2852         char *options;
2853 };
2854
2855 /*!
2856  * \brief Parses an IAX dial string into its component parts.
2857  * \param data the string to be parsed
2858  * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2859  * \return nothing
2860  *
2861  * This function parses the string and fills the structure
2862  * with pointers to its component parts. The input string
2863  * will be modified.
2864  *
2865  * \note This function supports both plaintext passwords and RSA
2866  * key names; if the password string is formatted as '[keyname]',
2867  * then the keyname will be placed into the key field, and the
2868  * password field will be set to NULL.
2869  *
2870  * \note The dial string format is:
2871  *       [username[:password]@]peer[:port][/exten[@@context]][/options]
2872  */
2873 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2874 {
2875         if (ast_strlen_zero(data))
2876                 return;
2877
2878         pds->peer = strsep(&data, "/");
2879         pds->exten = strsep(&data, "/");
2880         pds->options = data;
2881
2882         if (pds->exten) {
2883                 data = pds->exten;
2884                 pds->exten = strsep(&data, "@");
2885                 pds->context = data;
2886         }
2887
2888         if (strchr(pds->peer, '@')) {
2889                 data = pds->peer;
2890                 pds->username = strsep(&data, "@");
2891                 pds->peer = data;
2892         }
2893
2894         if (pds->username) {
2895                 data = pds->username;
2896                 pds->username = strsep(&data, ":");
2897                 pds->password = data;
2898         }
2899
2900         data = pds->peer;
2901         pds->peer = strsep(&data, ":");
2902         pds->port = data;
2903
2904         /* check for a key name wrapped in [] in the secret position, if found,
2905            move it to the key field instead
2906         */
2907         if (pds->password && (pds->password[0] == '[')) {
2908                 pds->key = ast_strip_quoted(pds->password, "[", "]");
2909                 pds->password = NULL;
2910         }
2911 }
2912
2913 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2914 {
2915         struct sockaddr_in sin;
2916         char *l=NULL, *n=NULL, *tmpstr;
2917         struct iax_ie_data ied;
2918         char *defaultrdest = "s";
2919         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2920         struct parsed_dial_string pds;
2921         struct create_addr_info cai;
2922         struct ast_var_t *var;
2923         const char* osp_token_ptr;
2924         unsigned int osp_token_length;
2925         unsigned char osp_block_index;
2926         unsigned int osp_block_length;
2927         unsigned char osp_buffer[256];
2928
2929         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2930                 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
2931                 return -1;
2932         }
2933
2934         memset(&cai, 0, sizeof(cai));
2935         cai.encmethods = iax2_encryption;
2936
2937         memset(&pds, 0, sizeof(pds));
2938         tmpstr = ast_strdupa(dest);
2939         parse_dial_string(tmpstr, &pds);
2940
2941         if (!pds.exten)
2942                 pds.exten = defaultrdest;
2943
2944         if (create_addr(pds.peer, &sin, &cai)) {
2945                 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
2946                 return -1;
2947         }
2948
2949         if (!pds.username && !ast_strlen_zero(cai.username))
2950                 pds.username = cai.username;
2951         if (!pds.password && !ast_strlen_zero(cai.secret))
2952                 pds.password = cai.secret;
2953         if (!pds.key && !ast_strlen_zero(cai.outkey))
2954                 pds.key = cai.outkey;
2955         if (!pds.context && !ast_strlen_zero(cai.peercontext))
2956                 pds.context = cai.peercontext;
2957
2958         /* Keep track of the context for outgoing calls too */
2959         ast_copy_string(c->context, cai.context, sizeof(c->context));
2960
2961         if (pds.port)
2962                 sin.sin_port = htons(atoi(pds.port));
2963
2964         l = c->cid.cid_num;
2965         n = c->cid.cid_name;
2966
2967         /* Now build request */ 
2968         memset(&ied, 0, sizeof(ied));
2969
2970         /* On new call, first IE MUST be IAX version of caller */
2971         iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2972         iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
2973         if (pds.options && strchr(pds.options, 'a')) {
2974                 /* Request auto answer */
2975                 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
2976         }
2977
2978         iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
2979
2980         if (l) {
2981                 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
2982                 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2983         } else {
2984                 if (n)
2985                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2986                 else
2987                         iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
2988         }
2989
2990         iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
2991         iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
2992
2993         if (n)
2994                 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
2995         if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
2996                 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
2997
2998         if (!ast_strlen_zero(c->language))
2999                 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
3000         if (!ast_strlen_zero(c->cid.cid_dnid))
3001                 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
3002         if (!ast_strlen_zero(c->cid.cid_rdnis))
3003                 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
3004
3005         if (pds.context)
3006                 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
3007
3008         if (pds.username)
3009                 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
3010
3011         if (cai.encmethods)
3012                 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
3013
3014         ast_mutex_lock(&iaxsl[callno]);
3015
3016         if (!ast_strlen_zero(c->context))
3017                 ast_string_field_set(iaxs[callno], context, c->context);
3018
3019         if (pds.username)
3020                 ast_string_field_set(iaxs[callno], username, pds.username);
3021
3022         iaxs[callno]->encmethods = cai.encmethods;
3023
3024         iaxs[callno]->adsi = cai.adsi;
3025         
3026         ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
3027         ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
3028
3029         if (pds.key)
3030                 ast_string_field_set(iaxs[callno], outkey, pds.key);
3031         if (pds.password)
3032                 ast_string_field_set(iaxs[callno], secret, pds.password);
3033
3034         iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
3035         iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
3036         iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
3037         iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
3038
3039         if (iaxs[callno]->maxtime) {
3040                 /* Initialize pingtime and auto-congest time */
3041                 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
3042                 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
3043         } else if (autokill) {
3044                 iaxs[callno]->pingtime = autokill / 2;
3045                 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
3046         }
3047
3048         /* Check if there is an OSP token set by IAXCHANINFO function */
3049         osp_token_ptr = iaxs[callno]->osptoken;
3050         if (!ast_strlen_zero(osp_token_ptr)) {
3051                 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
3052                         osp_block_index = 0;
3053                         while (osp_token_length > 0) {
3054                                 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
3055                                 osp_buffer[0] = osp_block_index;
3056                                 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
3057                                 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
3058                                 osp_block_index++;
3059                                 osp_token_ptr += osp_block_length;
3060                                 osp_token_length -= osp_block_length;
3061                         } 
3062                 } else
3063                         ast_log(LOG_WARNING, "OSP token is too long\n");
3064         } else if (option_debug && iaxdebug)
3065                 ast_log(LOG_DEBUG, "OSP token is undefined\n");
3066
3067         /* send the command using the appropriate socket for this peer */
3068         iaxs[callno]->sockfd = cai.sockfd;
3069
3070         /* Add remote vars */
3071         AST_LIST_TRAVERSE(&c->varshead, var, entries) {
3072                 if (!strncmp(ast_var_name(var), "~IAX2~", strlen("~IAX2~"))) {
3073                         char tmp[256];
3074                         int i;
3075                         /* Automatically divide the value up into sized chunks */
3076                         for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) - strlen("~IAX2~") + 1)) {
3077                                 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var) + strlen("~IAX2~"), ast_var_value(var) + i);
3078                                 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
3079                         }
3080                 }
3081         }
3082
3083         /* Transmit the string in a "NEW" request */
3084         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
3085
3086         ast_mutex_unlock(&iaxsl[callno]);
3087         ast_setstate(c, AST_STATE_RINGING);
3088         
3089         return 0;
3090 }
3091
3092 static int iax2_hangup(struct ast_channel *c) 
3093 {
3094         unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3095         int alreadygone;
3096         struct iax_ie_data ied;
3097         memset(&ied, 0, sizeof(ied));
3098         ast_mutex_lock(&iaxsl[callno]);
3099         if (callno && iaxs[callno]) {
3100                 if (option_debug)
3101                         ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
3102                 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
3103                 /* Send the hangup unless we have had a transmission error or are already gone */
3104                 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
3105                 if (!iaxs[callno]->error && !alreadygone) 
3106                         send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
3107                 /* Explicitly predestroy it */
3108                 iax2_predestroy(callno);
3109                 /* If we were already gone to begin with, destroy us now */
3110                 if (alreadygone) {
3111                         if (option_debug)
3112                                 ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
3113                         iax2_destroy(callno);
3114                 }
3115         }
3116         ast_mutex_unlock(&iaxsl[callno]);
3117         if (option_verbose > 2) 
3118                 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
3119         return 0;
3120 }
3121
3122 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
3123 {
3124         struct ast_option_header *h;
3125         int res;
3126
3127         switch (option) {
3128         case AST_OPTION_TXGAIN:
3129         case AST_OPTION_RXGAIN:
3130                 /* these two cannot be sent, because they require a result */
3131                 errno = ENOSYS;
3132                 return -1;
3133         default:
3134                 if (!(h = ast_malloc(datalen + sizeof(*h))))
3135                         return -1;
3136
3137                 h->flag = AST_OPTION_FLAG_REQUEST;
3138                 h->option = htons(option);
3139                 memcpy(h->data, data, datalen);
3140                 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
3141                                           AST_CONTROL_OPTION, 0, (unsigned char *) h,
3142                                           datalen + sizeof(*h), -1);
3143                 free(h);
3144                 return res;
3145         }
3146 }
3147
3148 static struct ast_frame *iax2_read(struct ast_channel *c) 
3149 {
3150         ast_log(LOG_NOTICE, "I should never be called!\n");
3151         return &ast_null_frame;
3152 }
3153
3154 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
3155 {
3156         int res;
3157         struct iax_ie_data ied0;
3158         struct iax_ie_data ied1;
3159         unsigned int transferid = (unsigned int)ast_random();
3160         memset(&ied0, 0, sizeof(ied0));
3161         iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
3162         iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
3163         iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
3164
3165         memset(&ied1, 0, sizeof(ied1));
3166         iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
3167         iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
3168         iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
3169         
3170         res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
3171         if (res)
3172                 return -1;
3173         res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
3174         if (res)
3175                 return -1;
3176         iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3177         iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
3178         return 0;
3179 }
3180
3181 static void lock_both(unsigned short callno0, unsigned short callno1)
3182 {
3183         ast_mutex_lock(&iaxsl[callno0]);
3184         while (ast_mutex_trylock(&iaxsl[callno1])) {
3185                 ast_mutex_unlock(&iaxsl[callno0]);
3186                 usleep(10);
3187                 ast_mutex_lock(&iaxsl[callno0]);
3188         }
3189 }
3190
3191 static void unlock_both(unsigned short callno0, unsigned short callno1)
3192 {
3193         ast_mutex_unlock(&iaxsl[callno1]);
3194         ast_mutex_unlock(&iaxsl[callno0]);