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