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