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