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