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