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