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