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