Whitespace changes only
[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, int full_frame)
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 == 0 || cur->peercallno == callno) &&
1392                          (full_frame ? dcallno == cur->callno : 1) ) {
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, int full_frame)
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], full_frame)) {
1507                                         res = x;
1508                                 }
1509                         }
1510                         if (!res || (res && !return_locked))
1511                                 ast_mutex_unlock(&iaxsl[x]);
1512                 }
1513                 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1514                         ast_mutex_lock(&iaxsl[x]);
1515                         if (iaxs[x]) {
1516                                 /* Look for an exact match */
1517                                 if (match(sin, callno, dcallno, iaxs[x], full_frame)) {
1518                                         res = x;
1519                                 }
1520                         }
1521                         if (!res || (res && !return_locked))
1522                                 ast_mutex_unlock(&iaxsl[x]);
1523                 }
1524         }
1525         if ((res < 1) && (new >= NEW_ALLOW)) {
1526                 int start, found = 0;
1527
1528                 /* It may seem odd that we look through the peer list for a name for
1529                  * this *incoming* call.  Well, it is weird.  However, users don't
1530                  * have an IP address/port number that we can match against.  So,
1531                  * this is just checking for a peer that has that IP/port and
1532                  * assuming that we have a user of the same name.  This isn't always
1533                  * correct, but it will be changed if needed after authentication. */
1534                 if (!iax2_getpeername(*sin, host, sizeof(host)))
1535                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1536
1537                 now = ast_tvnow();
1538                 start = 1 + (ast_random() % (TRUNK_CALL_START - 1));
1539                 for (x = start; 1; x++) {
1540                         if (x == TRUNK_CALL_START) {
1541                                 x = 0;
1542                                 continue;
1543                         }
1544
1545                         /* Find first unused call number that hasn't been used in a while */
1546                         ast_mutex_lock(&iaxsl[x]);
1547                         if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1548                                 found = 1;
1549                                 break;
1550                         }
1551                         ast_mutex_unlock(&iaxsl[x]);
1552                         
1553                         if (x == start - 1) {
1554                                 break;
1555                         }
1556                 }
1557                 /* We've still got lock held if we found a spot */
1558                 if (x == start - 1 && !found) {
1559                         ast_log(LOG_WARNING, "No more space\n");
1560                         return 0;
1561                 }
1562                 iaxs[x] = new_iax(sin, host);
1563                 update_max_nontrunk();
1564                 if (iaxs[x]) {
1565                         if (iaxdebug)
1566                                 ast_debug(1, "Creating new call structure %d\n", x);
1567                         iaxs[x]->sockfd = sockfd;
1568                         iaxs[x]->addr.sin_port = sin->sin_port;
1569                         iaxs[x]->addr.sin_family = sin->sin_family;
1570                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1571                         iaxs[x]->peercallno = callno;
1572                         iaxs[x]->callno = x;
1573                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1574                         iaxs[x]->expiry = min_reg_expire;
1575                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1576                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1577                         iaxs[x]->amaflags = amaflags;
1578                         ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1579                         
1580                         ast_string_field_set(iaxs[x], accountcode, accountcode);
1581                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1582                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1583                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
1584                 } else {
1585                         ast_log(LOG_WARNING, "Out of resources\n");
1586                         ast_mutex_unlock(&iaxsl[x]);
1587                         return 0;
1588                 }
1589                 if (!return_locked)
1590                         ast_mutex_unlock(&iaxsl[x]);
1591                 res = x;
1592         }
1593         return res;
1594 }
1595
1596 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1597
1598         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
1599 }
1600
1601 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
1602
1603         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
1604 }
1605
1606 static void iax2_frame_free(struct iax_frame *fr)
1607 {
1608         AST_SCHED_DEL(sched, fr->retrans);
1609         iax_frame_free(fr);
1610 }
1611
1612 /*!
1613  * \brief Queue a frame to a call's owning asterisk channel
1614  *
1615  * \pre This function assumes that iaxsl[callno] is locked when called.
1616  *
1617  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1618  * was valid before calling it, it may no longer be valid after calling it.
1619  * This function may unlock and lock the mutex associated with this callno,
1620  * meaning that another thread may grab it and destroy the call.
1621  */
1622 static int iax2_queue_frame(int callno, struct ast_frame *f)
1623 {
1624         for (;;) {
1625                 if (iaxs[callno] && iaxs[callno]->owner) {
1626                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1627                                 /* Avoid deadlock by pausing and trying again */
1628                                 ast_mutex_unlock(&iaxsl[callno]);
1629                                 usleep(1);
1630                                 ast_mutex_lock(&iaxsl[callno]);
1631                         } else {
1632                                 ast_queue_frame(iaxs[callno]->owner, f);
1633                                 ast_channel_unlock(iaxs[callno]->owner);
1634                                 break;
1635                         }
1636                 } else
1637                         break;
1638         }
1639         return 0;
1640 }
1641
1642 /*!
1643  * \brief Queue a hangup frame on the ast_channel owner
1644  *
1645  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
1646  * is active for the given call number.
1647  *
1648  * \pre Assumes lock for callno is already held.
1649  *
1650  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1651  * was valid before calling it, it may no longer be valid after calling it.
1652  * This function may unlock and lock the mutex associated with this callno,
1653  * meaning that another thread may grab it and destroy the call.
1654  */
1655 static int iax2_queue_hangup(int callno)
1656 {
1657         for (;;) {
1658                 if (iaxs[callno] && iaxs[callno]->owner) {
1659                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1660                                 /* Avoid deadlock by pausing and trying again */
1661                                 ast_mutex_unlock(&iaxsl[callno]);
1662                                 usleep(1);
1663                                 ast_mutex_lock(&iaxsl[callno]);
1664                         } else {
1665                                 ast_queue_hangup(iaxs[callno]->owner, -1);
1666                                 ast_channel_unlock(iaxs[callno]->owner);
1667                                 break;
1668                         }
1669                 } else
1670                         break;
1671         }
1672         return 0;
1673 }
1674
1675 /*!
1676  * \brief Queue a control frame on the ast_channel owner
1677  *
1678  * This function queues a control frame on the owner of the IAX2 pvt struct that
1679  * is active for the given call number.
1680  *
1681  * \pre Assumes lock for callno is already held.
1682  *
1683  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1684  * was valid before calling it, it may no longer be valid after calling it.
1685  * This function may unlock and lock the mutex associated with this callno,
1686  * meaning that another thread may grab it and destroy the call.
1687  */
1688 static int iax2_queue_control_data(int callno, 
1689         enum ast_control_frame_type control, const void *data, size_t datalen)
1690 {
1691         for (;;) {
1692                 if (iaxs[callno] && iaxs[callno]->owner) {
1693                         if (ast_channel_trylock(iaxs[callno]->owner)) {
1694                                 /* Avoid deadlock by pausing and trying again */
1695                                 ast_mutex_unlock(&iaxsl[callno]);
1696                                 usleep(1);
1697                                 ast_mutex_lock(&iaxsl[callno]);
1698                         } else {
1699                                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
1700                                 ast_channel_unlock(iaxs[callno]->owner);
1701                                 break;
1702                         }
1703                 } else
1704                         break;
1705         }
1706         return 0;
1707 }
1708 static void destroy_firmware(struct iax_firmware *cur)
1709 {
1710         /* Close firmware */
1711         if (cur->fwh) {
1712                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1713         }
1714         close(cur->fd);
1715         ast_free(cur);
1716 }
1717
1718 static int try_firmware(char *s)
1719 {
1720         struct stat stbuf;
1721         struct iax_firmware *cur = NULL;
1722         int ifd, fd, res, len, chunk;
1723         struct ast_iax2_firmware_header *fwh, fwh2;
1724         struct MD5Context md5;
1725         unsigned char sum[16], buf[1024];
1726         char *s2, *last;
1727
1728         if (!(s2 = alloca(strlen(s) + 100))) {
1729                 ast_log(LOG_WARNING, "Alloca failed!\n");
1730                 return -1;
1731         }
1732
1733         last = strrchr(s, '/');
1734         if (last)
1735                 last++;
1736         else
1737                 last = s;
1738
1739         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1740
1741         if ((res = stat(s, &stbuf) < 0)) {
1742                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1743                 return -1;
1744         }
1745
1746         /* Make sure it's not a directory */
1747         if (S_ISDIR(stbuf.st_mode))
1748                 return -1;
1749         ifd = open(s, O_RDONLY);
1750         if (ifd < 0) {
1751                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1752                 return -1;
1753         }
1754         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1755         if (fd < 0) {
1756                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1757                 close(ifd);
1758                 return -1;
1759         }
1760         /* Unlink our newly created file */
1761         unlink(s2);
1762         
1763         /* Now copy the firmware into it */
1764         len = stbuf.st_size;
1765         while(len) {
1766                 chunk = len;
1767                 if (chunk > sizeof(buf))
1768                         chunk = sizeof(buf);
1769                 res = read(ifd, buf, chunk);
1770                 if (res != chunk) {
1771                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1772                         close(ifd);
1773                         close(fd);
1774                         return -1;
1775                 }
1776                 res = write(fd, buf, chunk);
1777                 if (res != chunk) {
1778                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1779                         close(ifd);
1780                         close(fd);
1781                         return -1;
1782                 }
1783                 len -= chunk;
1784         }
1785         close(ifd);
1786         /* Return to the beginning */
1787         lseek(fd, 0, SEEK_SET);
1788         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1789                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1790                 close(fd);
1791                 return -1;
1792         }
1793         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1794                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1795                 close(fd);
1796                 return -1;
1797         }
1798         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1799                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1800                 close(fd);
1801                 return -1;
1802         }
1803         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1804                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1805                 close(fd);
1806                 return -1;
1807         }
1808         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
1809         if (fwh == (void *) -1) {
1810                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1811                 close(fd);
1812                 return -1;
1813         }
1814         MD5Init(&md5);
1815         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1816         MD5Final(sum, &md5);
1817         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1818                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1819                 munmap((void*)fwh, stbuf.st_size);
1820                 close(fd);
1821                 return -1;
1822         }
1823
1824         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1825                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1826                         /* Found a candidate */
1827                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1828                                 /* The version we have on loaded is older, load this one instead */
1829                                 break;
1830                         /* This version is no newer than what we have.  Don't worry about it.
1831                            We'll consider it a proper load anyhow though */
1832                         munmap((void*)fwh, stbuf.st_size);
1833                         close(fd);
1834                         return 0;
1835                 }
1836         }
1837         
1838         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1839                 cur->fd = -1;
1840                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1841         }
1842         
1843         if (cur) {
1844                 if (cur->fwh)
1845                         munmap((void*)cur->fwh, cur->mmaplen);
1846                 if (cur->fd > -1)
1847                         close(cur->fd);
1848                 cur->fwh = fwh;
1849                 cur->fd = fd;
1850                 cur->mmaplen = stbuf.st_size;
1851                 cur->dead = 0;
1852         }
1853         
1854         return 0;
1855 }
1856
1857 static int iax_check_version(char *dev)
1858 {
1859         int res = 0;
1860         struct iax_firmware *cur = NULL;
1861
1862         if (ast_strlen_zero(dev))
1863                 return 0;
1864
1865         AST_LIST_LOCK(&firmwares);
1866         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1867                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1868                         res = ntohs(cur->fwh->version);
1869                         break;
1870                 }
1871         }
1872         AST_LIST_UNLOCK(&firmwares);
1873
1874         return res;
1875 }
1876
1877 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1878 {
1879         int res = -1;
1880         unsigned int bs = desc & 0xff;
1881         unsigned int start = (desc >> 8) & 0xffffff;
1882         unsigned int bytes;
1883         struct iax_firmware *cur;
1884
1885         if (ast_strlen_zero((char *)dev) || !bs)
1886                 return -1;
1887
1888         start *= bs;
1889         
1890         AST_LIST_LOCK(&firmwares);
1891         AST_LIST_TRAVERSE(&firmwares, cur, list) {
1892                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1893                         continue;
1894                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1895                 if (start < ntohl(cur->fwh->datalen)) {
1896                         bytes = ntohl(cur->fwh->datalen) - start;
1897                         if (bytes > bs)
1898                                 bytes = bs;
1899                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1900                 } else {
1901                         bytes = 0;
1902                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1903                 }
1904                 if (bytes == bs)
1905                         res = 0;
1906                 else
1907                         res = 1;
1908                 break;
1909         }
1910         AST_LIST_UNLOCK(&firmwares);
1911
1912         return res;
1913 }
1914
1915
1916 static void reload_firmware(int unload)
1917 {
1918         struct iax_firmware *cur = NULL;
1919         DIR *fwd;
1920         struct dirent *de;
1921         char dir[256], fn[256];
1922
1923         AST_LIST_LOCK(&firmwares);
1924
1925         /* Mark all as dead */
1926         AST_LIST_TRAVERSE(&firmwares, cur, list)
1927                 cur->dead = 1;
1928
1929         /* Now that we have marked them dead... load new ones */
1930         if (!unload) {
1931                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
1932                 fwd = opendir(dir);
1933                 if (fwd) {
1934                         while((de = readdir(fwd))) {
1935                                 if (de->d_name[0] != '.') {
1936                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1937                                         if (!try_firmware(fn)) {
1938                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
1939                                         }
1940                                 }
1941                         }
1942                         closedir(fwd);
1943                 } else 
1944                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1945         }
1946
1947         /* Clean up leftovers */
1948         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1949                 if (!cur->dead)
1950                         continue;
1951                 AST_LIST_REMOVE_CURRENT(list);
1952                 destroy_firmware(cur);
1953         }
1954         AST_LIST_TRAVERSE_SAFE_END;
1955
1956         AST_LIST_UNLOCK(&firmwares);
1957 }
1958
1959 /*!
1960  * \note This function assumes that iaxsl[callno] is locked when called.
1961  *
1962  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1963  * was valid before calling it, it may no longer be valid after calling it.
1964  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
1965  * associated with this callno, meaning that another thread may grab it and destroy the call.
1966  */
1967 static int __do_deliver(void *data)
1968 {
1969         /* Just deliver the packet by using queueing.  This is called by
1970           the IAX thread with the iaxsl lock held. */
1971         struct iax_frame *fr = data;
1972         fr->retrans = -1;
1973         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
1974         if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1975                 iax2_queue_frame(fr->callno, &fr->af);
1976         /* Free our iax frame */
1977         iax2_frame_free(fr);
1978         /* And don't run again */
1979         return 0;
1980 }
1981
1982 static int handle_error(void)
1983 {
1984         /* XXX Ideally we should figure out why an error occurred and then abort those
1985            rather than continuing to try.  Unfortunately, the published interface does
1986            not seem to work XXX */
1987 #if 0
1988         struct sockaddr_in *sin;
1989         int res;
1990         struct msghdr m;
1991         struct sock_extended_err e;
1992         m.msg_name = NULL;
1993         m.msg_namelen = 0;
1994         m.msg_iov = NULL;
1995         m.msg_control = &e;
1996         m.msg_controllen = sizeof(e);
1997         m.msg_flags = 0;
1998         res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1999         if (res < 0)
2000                 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
2001         else {
2002                 if (m.msg_controllen) {
2003                         sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
2004                         if (sin) 
2005                                 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
2006                         else
2007                                 ast_log(LOG_WARNING, "No address detected??\n");
2008                 } else {
2009                         ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
2010                 }
2011         }
2012 #endif
2013         return 0;
2014 }
2015
2016 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
2017 {
2018         int res;
2019         res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
2020                                         sizeof(*sin));
2021         if (res < 0) {
2022                 ast_debug(1, "Received error: %s\n", strerror(errno));
2023                 handle_error();
2024         } else
2025                 res = 0;
2026         return res;
2027 }
2028
2029 static int send_packet(struct iax_frame *f)
2030 {
2031         int res;
2032         int callno = f->callno;
2033
2034         /* Don't send if there was an error, but return error instead */
2035         if (!callno || !iaxs[callno] || iaxs[callno]->error)
2036             return -1;
2037         
2038         /* Called with iaxsl held */
2039         if (iaxdebug)
2040                 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));
2041         if (f->transfer) {
2042                 if (iaxdebug)
2043                         iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
2044                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
2045                                         sizeof(iaxs[callno]->transfer));
2046         } else {
2047                 if (iaxdebug)
2048                         iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
2049                 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
2050                                         sizeof(iaxs[callno]->addr));
2051         }
2052         if (res < 0) {
2053                 if (iaxdebug)
2054                         ast_debug(1, "Received error: %s\n", strerror(errno));
2055                 handle_error();
2056         } else
2057                 res = 0;
2058         return res;
2059 }
2060
2061 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
2062 {
2063         /* Decrement AUTHREQ count if needed */
2064         if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
2065                 struct iax2_user *user;
2066                 struct iax2_user tmp_user = {
2067                         .name = pvt->username,
2068                 };
2069
2070                 user = ao2_find(users, &tmp_user, OBJ_POINTER);
2071                 if (user) {
2072                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
2073                         user_unref(user);       
2074                 }
2075
2076                 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
2077         }
2078         /* No more pings or lagrq's */
2079         AST_SCHED_DEL(sched, pvt->pingid);
2080         AST_SCHED_DEL(sched, pvt->lagid);
2081         AST_SCHED_DEL(sched, pvt->autoid);
2082         AST_SCHED_DEL(sched, pvt->authid);
2083         AST_SCHED_DEL(sched, pvt->initid);
2084         AST_SCHED_DEL(sched, pvt->jbid);
2085 }
2086
2087 /*!
2088  * \note Since this function calls iax2_queue_hangup(), the pvt struct
2089  *       for the given call number may disappear during its execution.
2090  */
2091 static int iax2_predestroy(int callno)
2092 {
2093         struct ast_channel *c = NULL;
2094         struct chan_iax2_pvt *pvt = iaxs[callno];
2095
2096         if (!pvt)
2097                 return -1;
2098
2099         if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
2100                 iax2_destroy_helper(pvt);
2101                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2102         }
2103
2104         if ((c = pvt->owner)) {
2105                 c->tech_pvt = NULL;
2106                 iax2_queue_hangup(callno);
2107                 pvt->owner = NULL;
2108                 ast_module_unref(ast_module_info->self);
2109         }
2110
2111         return 0;
2112 }
2113
2114 static void iax2_destroy(int callno)
2115 {
2116         struct chan_iax2_pvt *pvt = NULL;
2117         struct iax_frame *cur = NULL;
2118         struct ast_channel *owner = NULL;
2119
2120 retry:
2121         pvt = iaxs[callno];
2122         lastused[callno] = ast_tvnow();
2123         
2124         owner = pvt ? pvt->owner : NULL;
2125
2126         if (owner) {
2127                 if (ast_channel_trylock(owner)) {
2128                         ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
2129                         ast_mutex_unlock(&iaxsl[callno]);
2130                         usleep(1);
2131                         ast_mutex_lock(&iaxsl[callno]);
2132                         goto retry;
2133                 }
2134         }
2135         if (!owner)
2136                 iaxs[callno] = NULL;
2137         if (pvt) {
2138                 if (!owner)
2139                         pvt->owner = NULL;
2140                 iax2_destroy_helper(pvt);
2141
2142                 /* Already gone */
2143                 ast_set_flag(pvt, IAX_ALREADYGONE);     
2144
2145                 if (owner) {
2146                         /* If there's an owner, prod it to give up */
2147                         /* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
2148                          * because we already hold the owner channel lock. */
2149                         ast_queue_hangup(owner, -1);
2150                 }
2151
2152                 AST_LIST_LOCK(&frame_queue);
2153                 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2154                         /* Cancel any pending transmissions */
2155                         if (cur->callno == pvt->callno) 
2156                                 cur->retries = -1;
2157                 }
2158                 AST_LIST_UNLOCK(&frame_queue);
2159
2160                 if (pvt->reg)
2161                         pvt->reg->callno = 0;
2162                 if (!owner) {
2163                         jb_frame frame;
2164                         if (pvt->vars) {
2165                             ast_variables_destroy(pvt->vars);
2166                             pvt->vars = NULL;
2167                         }
2168
2169                         while (jb_getall(pvt->jb, &frame) == JB_OK)
2170                                 iax2_frame_free(frame.data);
2171                         jb_destroy(pvt->jb);
2172                         /* gotta free up the stringfields */
2173                         ast_string_field_free_memory(pvt);
2174                         ast_free(pvt);
2175                 }
2176         }
2177         if (owner) {
2178                 ast_channel_unlock(owner);
2179         }
2180         if (callno & 0x4000)
2181                 update_max_trunk();
2182 }
2183
2184 static int update_packet(struct iax_frame *f)
2185 {
2186         /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
2187         struct ast_iax2_full_hdr *fh = f->data;
2188         /* Mark this as a retransmission */
2189         fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
2190         /* Update iseqno */
2191         f->iseqno = iaxs[f->callno]->iseqno;
2192         fh->iseqno = f->iseqno;
2193         return 0;
2194 }
2195
2196 static int attempt_transmit(const void *data);
2197 static void __attempt_transmit(const void *data)
2198 {
2199         /* Attempt to transmit the frame to the remote peer...
2200            Called without iaxsl held. */
2201         struct iax_frame *f = (struct iax_frame *)data;
2202         int freeme = 0;
2203         int callno = f->callno;
2204         /* Make sure this call is still active */
2205         if (callno) 
2206                 ast_mutex_lock(&iaxsl[callno]);
2207         if (callno && iaxs[callno]) {
2208                 if ((f->retries < 0) /* Already ACK'd */ ||
2209                     (f->retries >= max_retries) /* Too many attempts */) {
2210                                 /* Record an error if we've transmitted too many times */
2211                                 if (f->retries >= max_retries) {
2212                                         if (f->transfer) {
2213                                                 /* Transfer timeout */
2214                                                 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
2215                                         } else if (f->final) {
2216                                                 if (f->final) 
2217                                                         iax2_destroy(callno);
2218                                         } else {
2219                                                 if (iaxs[callno]->owner)
2220                                                         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);
2221                                                 iaxs[callno]->error = ETIMEDOUT;
2222                                                 if (iaxs[callno]->owner) {
2223                                                         struct ast_frame fr = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .seqno = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
2224                                                         /* Hangup the fd */
2225                                                         iax2_queue_frame(callno, &fr); /* XXX */
2226                                                         /* Remember, owner could disappear */
2227                                                         if (iaxs[callno] && iaxs[callno]->owner)
2228                                                                 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
2229                                                 } else {
2230                                                         if (iaxs[callno]->reg) {
2231                                                                 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
2232                                                                 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
2233                                                                 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
2234                                                         }
2235                                                         iax2_destroy(callno);
2236                                                 }
2237                                         }
2238
2239                                 }
2240                                 freeme = 1;
2241                 } else {
2242                         /* Update it if it needs it */
2243                         update_packet(f);
2244                         /* Attempt transmission */
2245                         send_packet(f);
2246                         f->retries++;
2247                         /* Try again later after 10 times as long */
2248                         f->retrytime *= 10;
2249                         if (f->retrytime > MAX_RETRY_TIME)
2250                                 f->retrytime = MAX_RETRY_TIME;
2251                         /* Transfer messages max out at one second */
2252                         if (f->transfer && (f->retrytime > 1000))
2253                                 f->retrytime = 1000;
2254                         f->retrans = iax2_sched_add(sched, f->retrytime, attempt_transmit, f);
2255                 }
2256         } else {
2257                 /* Make sure it gets freed */
2258                 f->retries = -1;
2259                 freeme = 1;
2260         }
2261         if (callno)
2262                 ast_mutex_unlock(&iaxsl[callno]);
2263         /* Do not try again */
2264         if (freeme) {
2265                 /* Don't attempt delivery, just remove it from the queue */
2266                 AST_LIST_LOCK(&frame_queue);
2267                 AST_LIST_REMOVE(&frame_queue, f, list);
2268                 AST_LIST_UNLOCK(&frame_queue);
2269                 f->retrans = -1;
2270                 /* Free the IAX frame */
2271                 iax2_frame_free(f);
2272         }
2273 }
2274
2275 static int attempt_transmit(const void *data)
2276 {
2277 #ifdef SCHED_MULTITHREADED
2278         if (schedule_action(__attempt_transmit, data))
2279 #endif          
2280                 __attempt_transmit(data);
2281         return 0;
2282 }
2283
2284 static char *handle_cli_iax2_prune_realtime(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2285 {
2286         struct iax2_peer *peer;
2287
2288         switch (cmd) {
2289         case CLI_INIT:
2290                 e->command = "iax2 prune realtime";
2291                 e->usage =
2292                         "Usage: iax2 prune realtime [<peername>|all]\n"
2293                         "       Prunes object(s) from the cache\n";
2294                 return NULL;
2295         case CLI_GENERATE:
2296                 return complete_iax2_show_peer(a->line, a->word, a->pos, a->n);
2297         }
2298
2299         if (a->argc != 4)
2300         return CLI_SHOWUSAGE;
2301         if (!strcmp(a->argv[3], "all")) {
2302                 reload_config();
2303                 ast_cli(a->fd, "Cache flushed successfully.\n");
2304         } else if ((peer = find_peer(a->argv[3], 0))) {
2305                 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2306                         ast_set_flag(peer, IAX_RTAUTOCLEAR);
2307                         expire_registry(peer_ref(peer));
2308                         ast_cli(a->fd, "Peer %s was removed from the cache.\n", a->argv[3]);
2309                 } else {
2310                         ast_cli(a->fd, "Peer %s is not eligible for this operation.\n", a->argv[3]);
2311                 }
2312                 peer_unref(peer);
2313         } else {
2314                 ast_cli(a->fd, "Peer %s was not found in the cache.\n", a->argv[3]);
2315         }
2316         
2317         return CLI_SUCCESS;
2318 }
2319
2320 static char *handle_cli_iax2_test_losspct(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2321 {
2322         switch (cmd) {
2323         case CLI_INIT:
2324                 e->command = "iax2 test losspct";
2325                 e->usage =
2326                         "Usage: iax2 test losspct <percentage>\n"
2327                         "       For testing, throws away <percentage> percent of incoming packets\n";
2328                 return NULL;
2329         case CLI_GENERATE:
2330                 return NULL;
2331         }
2332         if (a->argc != 4)
2333                 return CLI_SHOWUSAGE;
2334
2335         test_losspct = atoi(a->argv[3]);
2336
2337         return CLI_SUCCESS;
2338 }
2339
2340 #ifdef IAXTESTS
2341 static char *handle_cli_iax2_test_late(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2342 {
2343         switch (cmd) {
2344         case CLI_INIT:
2345                 e->command = "iax2 test late";
2346                 e->usage =
2347                         "Usage: iax2 test late <ms>\n"
2348                         "       For testing, count the next frame as <ms> ms late\n";
2349                 return NULL;
2350         case CLI_GENERATE:
2351                 return NULL;
2352         }
2353
2354         if (a->argc != 4)
2355                 return CLI_SHOWUSAGE;
2356
2357         test_late = atoi(a->argv[3]);
2358
2359         return CLI_SUCCESS;
2360 }
2361
2362 static char *handle_cli_iax2_test_resync(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2363 {
2364         switch (cmd) {
2365         case CLI_INIT:
2366                 e->command = "iax2 test resync";
2367                 e->usage =
2368                         "Usage: iax2 test resync <ms>\n"
2369                         "       For testing, adjust all future frames by <ms> ms\n";
2370                 return NULL;
2371         case CLI_GENERATE:
2372                 return NULL;
2373         }
2374
2375         if (a->argc != 4)
2376                 return CLI_SHOWUSAGE;
2377
2378         test_resync = atoi(a->argv[3]);
2379
2380         return CLI_SUCCESS;
2381 }
2382
2383 static char *handle_cli_iax2_test_jitter(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2384 {
2385         switch (cmd) {
2386         case CLI_INIT:
2387                 e->command = "iax2 test jitter";
2388                 e->usage =
2389                         "Usage: iax2 test jitter <ms> <pct>\n"
2390                         "       For testing, simulate maximum jitter of +/- <ms> on <pct>\n"
2391                         "       percentage of packets. If <pct> is not specified, adds\n"
2392                         "       jitter to all packets.\n";
2393                 return NULL;
2394         case CLI_GENERATE:
2395                 return NULL;
2396         }
2397
2398         if (a->argc < 4 || a->argc > 5)
2399                 return CLI_SHOWUSAGE;
2400
2401         test_jit = atoi(a->argv[3]);
2402         if (a->argc == 5)
2403                 test_jitpct = atoi(a->argv[4]);
2404
2405         return CLI_SUCCESS;
2406 }
2407 #endif /* IAXTESTS */
2408
2409 /*! \brief  peer_status: Report Peer status in character string */
2410 /*      returns 1 if peer is online, -1 if unmonitored */
2411 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2412 {
2413         int res = 0;
2414         if (peer->maxms) {
2415                 if (peer->lastms < 0) {
2416                         ast_copy_string(status, "UNREACHABLE", statuslen);
2417                 } else if (peer->lastms > peer->maxms) {
2418                         snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2419                         res = 1;
2420                 } else if (peer->lastms) {
2421                         snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2422                         res = 1;
2423                 } else {
2424                         ast_copy_string(status, "UNKNOWN", statuslen);
2425                 }
2426         } else { 
2427                 ast_copy_string(status, "Unmonitored", statuslen);
2428                 res = -1;
2429         }
2430         return res;
2431 }
2432
2433 /*! \brief Show one peer in detail */
2434 static char *handle_cli_iax2_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2435 {
2436         char status[30];
2437         char cbuf[256];
2438         struct iax2_peer *peer;
2439         char codec_buf[512];
2440         int x = 0, codec = 0, load_realtime = 0;
2441
2442         switch (cmd) {
2443         case CLI_INIT:
2444                 e->command = "iax2 show peer";
2445                 e->usage =
2446                         "Usage: iax2 show peer <name>\n"
2447                         "       Display details on specific IAX peer\n";
2448                 return NULL;
2449         case CLI_GENERATE:
2450                 return complete_iax2_show_peer(a->line, a->word, a->pos, a->n);
2451         }
2452
2453         if (a->argc < 4)
2454                 return CLI_SHOWUSAGE;
2455
2456         load_realtime = (a->argc == 5 && !strcmp(a->argv[4], "load")) ? 1 : 0;
2457
2458         peer = find_peer(a->argv[3], load_realtime);
2459         if (peer) {
2460                 ast_cli(a->fd, "\n\n");
2461                 ast_cli(a->fd, "  * Name       : %s\n", peer->name);
2462                 ast_cli(a->fd, "  Secret       : %s\n", ast_strlen_zero(peer->secret) ? "<Not set>" : "<Set>");
2463                 ast_cli(a->fd, "  Context      : %s\n", peer->context);
2464                 ast_cli(a->fd, "  Parking lot  : %s\n", peer->parkinglot);
2465                 ast_cli(a->fd, "  Mailbox      : %s\n", peer->mailbox);
2466                 ast_cli(a->fd, "  Dynamic      : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes" : "No");
2467                 ast_cli(a->fd, "  Callerid     : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2468                 ast_cli(a->fd, "  Expire       : %d\n", peer->expire);
2469                 ast_cli(a->fd, "  ACL          : %s\n", (peer->ha ? "Yes" : "No"));
2470                 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));
2471                 ast_cli(a->fd, "  Defaddr->IP  : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2472                 ast_cli(a->fd, "  Username     : %s\n", peer->username);
2473                 ast_cli(a->fd, "  Codecs       : ");
2474                 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2475                 ast_cli(a->fd, "%s\n", codec_buf);
2476
2477                 ast_cli(a->fd, "  Codec Order  : (");
2478                 for(x = 0; x < 32 ; x++) {
2479                         codec = ast_codec_pref_index(&peer->prefs,x);
2480                         if(!codec)
2481                                 break;
2482                         ast_cli(a->fd, "%s", ast_getformatname(codec));
2483                         if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2484                                 ast_cli(a->fd, "|");
2485                 }
2486
2487                 if (!x)
2488                         ast_cli(a->fd, "none");
2489                 ast_cli(a->fd, ")\n");
2490
2491                 ast_cli(a->fd, "  Status       : ");
2492                 peer_status(peer, status, sizeof(status));      
2493                 ast_cli(a->fd, "%s\n",status);
2494                 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");
2495                 ast_cli(a->fd, "\n");
2496                 peer_unref(peer);
2497         } else {
2498                 ast_cli(a->fd, "Peer %s not found.\n", a->argv[3]);
2499                 ast_cli(a->fd, "\n");
2500         }
2501
2502         return CLI_SUCCESS;
2503 }
2504
2505 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2506 {
2507         int which = 0;
2508         struct iax2_peer *peer;
2509         char *res = NULL;
2510         int wordlen = strlen(word);
2511         struct ao2_iterator i;
2512
2513         /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2514         if (pos != 3)
2515                 return NULL;
2516
2517         i = ao2_iterator_init(peers, 0);
2518         while ((peer = ao2_iterator_next(&i))) {
2519                 if (!strncasecmp(peer->name, word, wordlen) && ++which > state) {
2520                         res = ast_strdup(peer->name);
2521                         peer_unref(peer);
2522                         break;
2523                 }
2524                 peer_unref(peer);
2525         }
2526
2527         return res;
2528 }
2529
2530 static char *handle_cli_iax2_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2531 {
2532         struct iax_frame *cur;
2533         int cnt = 0, dead = 0, final = 0;
2534
2535         switch (cmd) {
2536         case CLI_INIT:
2537                 e->command = "iax2 show stats";
2538                 e->usage =
2539                         "Usage: iax2 show stats\n"
2540                         "       Display statistics on IAX channel driver.\n";
2541                 return NULL;
2542         case CLI_GENERATE:
2543                 return NULL;
2544         }
2545
2546         if (a->argc != 3)
2547                 return CLI_SHOWUSAGE;
2548
2549         AST_LIST_LOCK(&frame_queue);
2550         AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2551                 if (cur->retries < 0)
2552                         dead++;
2553                 if (cur->final)
2554                         final++;
2555                 cnt++;
2556         }
2557         AST_LIST_UNLOCK(&frame_queue);
2558
2559         ast_cli(a->fd, "    IAX Statistics\n");
2560         ast_cli(a->fd, "---------------------\n");
2561         ast_cli(a->fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2562         ast_cli(a->fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2563                 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2564         ast_cli(a->fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2565
2566         trunk_timed = trunk_untimed = 0;
2567         if (trunk_maxmtu > trunk_nmaxmtu)
2568                 trunk_nmaxmtu = trunk_maxmtu;
2569
2570         return CLI_SUCCESS;
2571 }
2572
2573 /*! \brief Set trunk MTU from CLI */
2574 static char *handle_cli_iax2_set_mtu(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2575 {
2576         int mtuv;
2577
2578         switch (cmd) {
2579         case CLI_INIT:
2580                 e->command = "iax2 set mtu";
2581                 e->usage =
2582                         "Usage: iax2 set mtu <value>\n"
2583                         "       Set the system-wide IAX IP mtu to <value> bytes net or\n"
2584                         "       zero to disable. Disabling means that the operating system\n"
2585                         "       must handle fragmentation of UDP packets when the IAX2 trunk\n"
2586                         "       packet exceeds the UDP payload size. This is substantially\n"
2587                         "       below the IP mtu. Try 1240 on ethernets. Must be 172 or\n"
2588                         "       greater for G.711 samples.\n";
2589                 return NULL;
2590         case CLI_GENERATE:
2591                 return NULL;
2592         }
2593
2594         if (a->argc != 4)
2595                 return CLI_SHOWUSAGE; 
2596         if (strncasecmp(a->argv[3], "default", strlen(a->argv[3])) == 0)
2597                 mtuv = MAX_TRUNK_MTU;
2598         else
2599                 mtuv = atoi(a->argv[3]);
2600
2601         if (mtuv == 0) {
2602                 ast_cli(a->fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu); 
2603                 global_max_trunk_mtu = 0; 
2604                 return CLI_SUCCESS; 
2605         }
2606         if (mtuv < 172 || mtuv > 4000) {
2607                 ast_cli(a->fd, "Trunk MTU must be between 172 and 4000\n"); 
2608                 return CLI_SHOWUSAGE; 
2609         }
2610         ast_cli(a->fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv); 
2611         global_max_trunk_mtu = mtuv; 
2612         return CLI_SUCCESS;
2613 }
2614
2615 static char *handle_cli_iax2_show_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2616 {
2617         struct iax2_dpcache *dp = NULL;
2618         char tmp[1024], *pc = NULL;
2619         int s, x, y;
2620         struct timeval tv = ast_tvnow();
2621
2622         switch (cmd) {
2623         case CLI_INIT:
2624                 e->command = "iax2 show cache";
2625                 e->usage =
2626                         "Usage: iax2 show cache\n"
2627                         "       Display currently cached IAX Dialplan results.\n";
2628                 return NULL;
2629         case CLI_GENERATE:
2630                 return NULL;
2631         }
2632
2633         AST_LIST_LOCK(&dpcache);
2634
2635         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2636
2637         AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2638                 s = dp->expiry.tv_sec - tv.tv_sec;
2639                 tmp[0] = '\0';
2640                 if (dp->flags & CACHE_FLAG_EXISTS)
2641                         strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2642                 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2643                         strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2644                 if (dp->flags & CACHE_FLAG_CANEXIST)
2645                         strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2646                 if (dp->flags & CACHE_FLAG_PENDING)
2647                         strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2648                 if (dp->flags & CACHE_FLAG_TIMEOUT)
2649                         strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2650                 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2651                         strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2652                 if (dp->flags & CACHE_FLAG_MATCHMORE)
2653                         strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2654                 if (dp->flags & CACHE_FLAG_UNKNOWN)
2655                         strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2656                 /* Trim trailing pipe */
2657                 if (!ast_strlen_zero(tmp))
2658                         tmp[strlen(tmp) - 1] = '\0';
2659                 else
2660                         ast_copy_string(tmp, "(none)", sizeof(tmp));
2661                 y = 0;
2662                 pc = strchr(dp->peercontext, '@');
2663                 if (!pc)
2664                         pc = dp->peercontext;
2665                 else
2666                         pc++;
2667                 for (x = 0; x < sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2668                         if (dp->waiters[x] > -1)
2669                                 y++;
2670                 if (s > 0)
2671                         ast_cli(a->fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2672                 else
2673                         ast_cli(a->fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2674         }
2675
2676         AST_LIST_LOCK(&dpcache);
2677
2678         return CLI_SUCCESS;
2679 }
2680
2681 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2682
2683 static void unwrap_timestamp(struct iax_frame *fr)
2684 {
2685         int x;
2686
2687         if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2688                 x = fr->ts - iaxs[fr->callno]->last;
2689                 if (x < -50000) {
2690                         /* Sudden big jump backwards in timestamp:
2691                            What likely happened here is that miniframe timestamp has circled but we haven't
2692                            gotten the update from the main packet.  We'll just pretend that we did, and
2693                            update the timestamp appropriately. */
2694                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2695                         if (iaxdebug)
2696                                 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2697                 }
2698                 if (x > 50000) {
2699                         /* Sudden apparent big jump forwards in timestamp:
2700                            What's likely happened is this is an old miniframe belonging to the previous
2701                            top-16-bit timestamp that has turned up out of order.
2702                            Adjust the timestamp appropriately. */
2703                         fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2704                         if (iaxdebug)
2705                                 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2706                 }
2707         }
2708 }
2709
2710 static int get_from_jb(const void *p);
2711
2712 static void update_jbsched(struct chan_iax2_pvt *pvt)
2713 {
2714         int when;
2715         
2716         when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2717         
2718         when = jb_next(pvt->jb) - when;
2719
2720         if (when <= 0) {
2721                 /* XXX should really just empty until when > 0.. */
2722                 when = 1;
2723         }
2724         
2725         pvt->jbid = iax2_sched_replace(pvt->jbid, sched, when, get_from_jb, 
2726                 CALLNO_TO_PTR(pvt->callno));
2727 }
2728
2729 static void __get_from_jb(const void *p) 
2730 {
2731         int callno = PTR_TO_CALLNO(p);
2732         struct chan_iax2_pvt *pvt = NULL;
2733         struct iax_frame *fr;
2734         jb_frame frame;
2735         int ret;
2736         long now;
2737         long next;
2738         struct timeval tv = ast_tvnow();
2739         
2740         /* Make sure we have a valid private structure before going on */
2741         ast_mutex_lock(&iaxsl[callno]);
2742         pvt = iaxs[callno];
2743         if (!pvt) {
2744                 /* No go! */
2745                 ast_mutex_unlock(&iaxsl[callno]);
2746                 return;
2747         }
2748
2749         pvt->jbid = -1;
2750         
2751         /* round up a millisecond since ast_sched_runq does; */
2752         /* prevents us from spinning while waiting for our now */
2753         /* to catch up with runq's now */
2754         tv.tv_usec += 1000;
2755         
2756         now = ast_tvdiff_ms(tv, pvt->rxcore);
2757         
2758         if(now >= (next = jb_next(pvt->jb))) {
2759                 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2760                 switch(ret) {
2761                 case JB_OK:
2762                         fr = frame.data;
2763                         __do_deliver(fr);
2764                         /* __do_deliver() can cause the call to disappear */
2765                         pvt = iaxs[callno];
2766                         break;
2767                 case JB_INTERP:
2768                 {
2769                         struct ast_frame af = { 0, };
2770                         
2771                         /* create an interpolation frame */
2772                         af.frametype = AST_FRAME_VOICE;
2773                         af.subclass = pvt->voiceformat;
2774                         af.samples  = frame.ms * 8;
2775                         af.src  = "IAX2 JB interpolation";
2776                         af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2777                         af.offset = AST_FRIENDLY_OFFSET;
2778                         
2779                         /* queue the frame:  For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2780                          * which we'd need to malloc, and then it would free it.  That seems like a drag */
2781                         if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2782                                 iax2_queue_frame(callno, &af);
2783                                 /* iax2_queue_frame() could cause the call to disappear */
2784                                 pvt = iaxs[callno];
2785                         }
2786                 }
2787                         break;
2788                 case JB_DROP:
2789                         iax2_frame_free(frame.data);
2790                         break;
2791                 case JB_NOFRAME:
2792                 case JB_EMPTY:
2793                         /* do nothing */
2794                         break;
2795                 default:
2796                         /* shouldn't happen */
2797                         break;
2798                 }
2799         }
2800         if (pvt)
2801                 update_jbsched(pvt);
2802         ast_mutex_unlock(&iaxsl[callno]);
2803 }
2804
2805 static int get_from_jb(const void *data)
2806 {
2807 #ifdef SCHED_MULTITHREADED
2808         if (schedule_action(__get_from_jb, data))
2809 #endif          
2810                 __get_from_jb(data);
2811         return 0;
2812 }
2813
2814 /*!
2815  * \note This function assumes fr->callno is locked
2816  *
2817  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2818  * was valid before calling it, it may no longer be valid after calling it.
2819  */
2820 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2821 {
2822         int type, len;
2823         int ret;
2824         int needfree = 0;
2825         struct ast_channel *owner = NULL;
2826         struct ast_channel *bridge = NULL;
2827         
2828         /* Attempt to recover wrapped timestamps */
2829         unwrap_timestamp(fr);
2830
2831         /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2832         if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2833                 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2834         else {
2835 #if 0
2836                 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2837 #endif
2838                 fr->af.delivery = ast_tv(0,0);
2839         }
2840
2841         type = JB_TYPE_CONTROL;
2842         len = 0;
2843
2844         if(fr->af.frametype == AST_FRAME_VOICE) {
2845                 type = JB_TYPE_VOICE;
2846                 len = ast_codec_get_samples(&fr->af) / 8;
2847         } else if(fr->af.frametype == AST_FRAME_CNG) {
2848                 type = JB_TYPE_SILENCE;
2849         }
2850
2851         if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2852                 if (tsout)
2853                         *tsout = fr->ts;
2854                 __do_deliver(fr);
2855                 return -1;
2856         }
2857
2858         if ((owner = iaxs[fr->callno]->owner))
2859                 bridge = ast_bridged_channel(owner);
2860
2861         /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2862          * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2863         if ( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) && owner && bridge && (bridge->tech->properties & AST_CHAN_TP_WANTSJITTER) ) {
2864                 jb_frame frame;
2865
2866                 /* deliver any frames in the jb */
2867                 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2868                         __do_deliver(frame.data);
2869                         /* __do_deliver() can make the call disappear */
2870                         if (!iaxs[fr->callno])
2871                                 return -1;
2872                 }
2873
2874                 jb_reset(iaxs[fr->callno]->jb);
2875
2876                 AST_SCHED_DEL(sched, iaxs[fr->callno]->jbid);
2877
2878                 /* deliver this frame now */
2879                 if (tsout)
2880                         *tsout = fr->ts;
2881                 __do_deliver(fr);
2882                 return -1;
2883         }
2884
2885         /* insert into jitterbuffer */
2886         /* TODO: Perhaps we could act immediately if it's not droppable and late */
2887         ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2888                         calc_rxstamp(iaxs[fr->callno],fr->ts));
2889         if (ret == JB_DROP) {
2890                 needfree++;
2891         } else if (ret == JB_SCHED) {
2892                 update_jbsched(iaxs[fr->callno]);
2893         }
2894         if (tsout)
2895                 *tsout = fr->ts;
2896         if (needfree) {
2897                 /* Free our iax frame */
2898                 iax2_frame_free(fr);
2899                 return -1;
2900         }
2901         return 0;
2902 }
2903
2904 static int iax2_transmit(struct iax_frame *fr)
2905 {
2906         /* Lock the queue and place this packet at the end */
2907         /* By setting this to 0, the network thread will send it for us, and
2908            queue retransmission if necessary */
2909         fr->sentyet = 0;
2910         AST_LIST_LOCK(&frame_queue);
2911         AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
2912         AST_LIST_UNLOCK(&frame_queue);
2913         /* Wake up the network and scheduler thread */
2914         if (netthreadid != AST_PTHREADT_NULL)
2915                 pthread_kill(netthreadid, SIGURG);
2916         signal_condition(&sched_lock, &sched_cond);
2917         return 0;
2918 }
2919
2920
2921
2922 static int iax2_digit_begin(struct ast_channel *c, char digit)
2923 {
2924         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2925 }
2926
2927 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2928 {
2929         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2930 }
2931
2932 static int iax2_sendtext(struct ast_channel *c, const char *text)
2933 {
2934         
2935         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2936                 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2937 }
2938
2939 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2940 {
2941         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2942 }
2943
2944 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2945 {
2946         return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2947 }
2948
2949 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2950 {
2951         unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2952         ast_mutex_lock(&iaxsl[callno]);
2953         if (iaxs[callno])
2954                 iaxs[callno]->owner = newchan;
2955         else
2956                 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2957         ast_mutex_unlock(&iaxsl[callno]);
2958         return 0;
2959 }
2960
2961 /*!
2962  * \note This function calls reg_source_db -> iax2_poke_peer -> find_callno,
2963  *       so do not call this with a pvt lock held.
2964  */
2965 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2966 {
2967         struct ast_variable *var = NULL;
2968         struct ast_variable *tmp;
2969         struct iax2_peer *peer=NULL;
2970         time_t regseconds = 0, nowtime;
2971         int dynamic=0;
2972
2973         if (peername) {
2974                 var = ast_load_realtime("iaxpeers", "name", peername, "host", "dynamic", NULL);
2975                 if (!var && sin)
2976                         var = ast_load_realtime("iaxpeers", "name", peername, "host", ast_inet_ntoa(sin->sin_addr), NULL);
2977         } else if (sin) {
2978                 char porta[25];
2979                 sprintf(porta, "%d", ntohs(sin->sin_port));
2980                 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2981                 if (var) {
2982                         /* We'll need the peer name in order to build the structure! */
2983                         for (tmp = var; tmp; tmp = tmp->next) {
2984                                 if (!strcasecmp(tmp->name, "name"))
2985                                         peername = tmp->value;
2986                         }
2987                 }
2988         }
2989         if (!var && peername) { /* Last ditch effort */
2990                 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2991                 /*!\note
2992                  * If this one loaded something, then we need to ensure that the host
2993                  * field matched.  The only reason why we can't have this as a criteria
2994                  * is because we only have the IP address and the host field might be
2995                  * set as a name (and the reverse PTR might not match).
2996                  */
2997                 if (var && sin) {
2998                         for (tmp = var; tmp; tmp = tmp->next) {
2999                                 if (!strcasecmp(tmp->name, "host")) {
3000                                         struct ast_hostent ahp;
3001                                         struct hostent *hp;
3002                                         if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || (memcmp(&hp->h_addr, &sin->sin_addr, sizeof(hp->h_addr)))) {
3003                                                 /* No match */
3004                                                 ast_variables_destroy(var);
3005                                                 var = NULL;
3006                                         }
3007                                         break;
3008                                 }
3009                         }
3010                 }
3011         }
3012         if (!var)
3013                 return NULL;
3014
3015         peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
3016         
3017         if (!peer) {
3018                 ast_variables_destroy(var);
3019                 return NULL;
3020         }
3021
3022         for (tmp = var; tmp; tmp = tmp->next) {
3023                 /* Make sure it's not a user only... */
3024                 if (!strcasecmp(tmp->name, "type")) {
3025                         if (strcasecmp(tmp->value, "friend") &&
3026                             strcasecmp(tmp->value, "peer")) {
3027                                 /* Whoops, we weren't supposed to exist! */
3028                                 peer = peer_unref(peer);
3029                                 break;
3030                         } 
3031                 } else if (!strcasecmp(tmp->name, "regseconds")) {
3032                         ast_get_time_t(tmp->value, &regseconds, 0, NULL);
3033                 } else if (!strcasecmp(tmp->name, "ipaddr")) {
3034                         inet_aton(tmp->value, &(peer->addr.sin_addr));
3035                 } else if (!strcasecmp(tmp->name, "port")) {
3036                         peer->addr.sin_port = htons(atoi(tmp->value));
3037                 } else if (!strcasecmp(tmp->name, "host")) {
3038                         if (!strcasecmp(tmp->value, "dynamic"))
3039                                 dynamic = 1;
3040                 }
3041         }
3042
3043         ast_variables_destroy(var);
3044
3045         if (!peer)
3046                 return NULL;
3047
3048         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
3049                 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
3050                 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
3051                         if (peer->expire > -1) {
3052                                 if (!ast_sched_del(sched, peer->expire)) {
3053                                         peer->expire = -1;
3054                                         peer_unref(peer);
3055                                 }
3056                         }
3057                         peer->expire = iax2_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, peer_ref(peer));
3058                         if (peer->expire == -1)
3059                                 peer_unref(peer);
3060                 }
3061                 ao2_link(peers, peer);
3062                 if (ast_test_flag(peer, IAX_DYNAMIC))
3063                         reg_source_db(peer);
3064         } else {
3065                 ast_set_flag(peer, IAX_TEMPONLY);       
3066         }
3067
3068         if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
3069                 time(&nowtime);
3070                 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
3071                         memset(&peer->addr, 0, sizeof(peer->addr));
3072                         realtime_update_peer(peer->name, &peer->addr, 0);
3073                         ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
3074                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
3075                 }
3076                 else {
3077                         ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
3078                                 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
3079                 }
3080         }
3081
3082         return peer;
3083 }
3084
3085 static struct iax2_user *realtime_user(const char *username, struct sockaddr_in *sin)
3086 {
3087         struct ast_variable *var;
3088         struct ast_variable *tmp;
3089         struct iax2_user *user=NULL;
3090
3091         var = ast_load_realtime("iaxusers", "name", username, "host", "dynamic", NULL);
3092         if (!var)
3093                 var = ast_load_realtime("iaxusers", "name", username, "host", ast_inet_ntoa(sin->sin_addr), NULL);
3094         if (!var && sin) {
3095                 char porta[6];
3096                 snprintf(porta, sizeof(porta), "%d", ntohs(sin->sin_port));
3097                 var = ast_load_realtime("iaxusers", "name", username, "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
3098                 if (!var)
3099                         var = ast_load_realtime("iaxusers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
3100         }
3101         if (!var) { /* Last ditch effort */
3102                 var = ast_load_realtime("iaxusers", "name", username, NULL);
3103                 /*!\note
3104                  * If this one loaded something, then we need to ensure that the host
3105                  * field matched.  The only reason why we can't have this as a criteria
3106                  * is because we only have the IP address and the host field might be
3107                  * set as a name (and the reverse PTR might not match).
3108                  */
3109                 if (var) {
3110                         for (tmp = var; tmp; tmp = tmp->next) {
3111                                 if (!strcasecmp(tmp->name, "host")) {
3112                                         struct ast_hostent ahp;
3113                                         struct hostent *hp;
3114                                         if (!(hp = ast_gethostbyname(tmp->value, &ahp)) || (memcmp(&hp->h_addr, &sin->sin_addr, sizeof(hp->h_addr)))) {
3115                                                 /* No match */
3116                                                 ast_variables_destroy(var);
3117                                                 var = NULL;
3118                                         }
3119                                         break;
3120                                 }
3121                         }
3122                 }
3123         }
3124         if (!var)
3125                 return NULL;
3126
3127         tmp = var;
3128         while(tmp) {
3129                 /* Make sure it's not a peer only... */
3130                 if (!strcasecmp(tmp->name, "type")) {
3131                         if (strcasecmp(tmp->value, "friend") &&
3132                             strcasecmp(tmp->value, "user")) {
3133                                 return NULL;
3134                         } 
3135                 }
3136                 tmp = tmp->next;
3137         }
3138
3139         user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
3140
3141         ast_variables_destroy(var);
3142
3143         if (!user)
3144                 return NULL;
3145
3146         if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
3147                 ast_set_flag(user, IAX_RTCACHEFRIENDS);
3148                 ao2_link(users, user);
3149         } else {
3150                 ast_set_flag(user, IAX_TEMPONLY);       
3151         }
3152
3153         return user;
3154 }
3155
3156 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
3157 {
3158         char port[10];
3159         char regseconds[20];
3160         
3161         snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
3162         snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
3163         ast_update_realtime("iaxpeers", "name", peername, 
3164                 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port, 
3165                 "regseconds", regseconds, NULL);
3166 }
3167
3168 struct create_addr_info {