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