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