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