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