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