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