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