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