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