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