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