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