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