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