85d997fc2ffaa2bf882eb388b44d69677ed02a9c
[asterisk/asterisk.git] / res / res_rtp_asterisk.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, 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 /*!
20  * \file
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  *
26  * \note RTP is defined in RFC 3550.
27  *
28  * \ingroup rtp_engines
29  */
30
31 /*** MODULEINFO
32         <use type="external">pjproject</use>
33         <support_level>core</support_level>
34  ***/
35
36 #include "asterisk.h"
37
38 ASTERISK_REGISTER_FILE()
39
40 #include <sys/time.h>
41 #include <signal.h>
42 #include <fcntl.h>
43
44 #ifdef HAVE_OPENSSL_SRTP
45 #include <openssl/ssl.h>
46 #include <openssl/err.h>
47 #include <openssl/bio.h>
48 #endif
49
50 #ifdef HAVE_PJPROJECT
51 #include <pjlib.h>
52 #include <pjlib-util.h>
53 #include <pjnath.h>
54 #endif
55
56 #include "asterisk/stun.h"
57 #include "asterisk/pbx.h"
58 #include "asterisk/frame.h"
59 #include "asterisk/format_cache.h"
60 #include "asterisk/channel.h"
61 #include "asterisk/acl.h"
62 #include "asterisk/config.h"
63 #include "asterisk/lock.h"
64 #include "asterisk/utils.h"
65 #include "asterisk/cli.h"
66 #include "asterisk/manager.h"
67 #include "asterisk/unaligned.h"
68 #include "asterisk/module.h"
69 #include "asterisk/rtp_engine.h"
70 #include "asterisk/smoother.h"
71 #include "asterisk/test.h"
72
73 #define MAX_TIMESTAMP_SKEW      640
74
75 #define RTP_SEQ_MOD     (1<<16) /*!< A sequence number can't be more than 16 bits */
76 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
77 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
78 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
79
80 #define DEFAULT_RTP_START 5000 /*!< Default port number to start allocating RTP ports from */
81 #define DEFAULT_RTP_END 31000  /*!< Default maximum port number to end allocating RTP ports at */
82
83 #define MINIMUM_RTP_PORT 1024 /*!< Minimum port number to accept */
84 #define MAXIMUM_RTP_PORT 65535 /*!< Maximum port number to accept */
85
86 #define DEFAULT_TURN_PORT 3478
87
88 #define TURN_STATE_WAIT_TIME 2000
89
90 #define RTCP_PT_FUR     192
91 #define RTCP_PT_SR      AST_RTP_RTCP_SR
92 #define RTCP_PT_RR      AST_RTP_RTCP_RR
93 #define RTCP_PT_SDES    202
94 #define RTCP_PT_BYE     203
95 #define RTCP_PT_APP     204
96 /* VP8: RTCP Feedback */
97 #define RTCP_PT_PSFB    206
98
99 #define RTP_MTU         1200
100 #define DTMF_SAMPLE_RATE_MS    8 /*!< DTMF samples per millisecond */
101
102 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))      /*!< samples */
103
104 #define ZFONE_PROFILE_ID 0x505a
105
106 #define DEFAULT_LEARNING_MIN_SEQUENTIAL 4
107
108 #define SRTP_MASTER_KEY_LEN 16
109 #define SRTP_MASTER_SALT_LEN 14
110 #define SRTP_MASTER_LEN (SRTP_MASTER_KEY_LEN + SRTP_MASTER_SALT_LEN)
111
112 enum strict_rtp_state {
113         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
114         STRICT_RTP_LEARN,    /*! Accept next packet as source */
115         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
116 };
117
118 #define DEFAULT_STRICT_RTP STRICT_RTP_CLOSED
119 #define DEFAULT_ICESUPPORT 1
120
121 extern struct ast_srtp_res *res_srtp;
122 extern struct ast_srtp_policy_res *res_srtp_policy;
123
124 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
125
126 static int rtpstart = DEFAULT_RTP_START;                        /*!< First port for RTP sessions (set in rtp.conf) */
127 static int rtpend = DEFAULT_RTP_END;                    /*!< Last port for RTP sessions (set in rtp.conf) */
128 static int rtpdebug;                    /*!< Are we debugging? */
129 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
130 static int rtcpstats;                   /*!< Are we debugging RTCP? */
131 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
132 static struct ast_sockaddr rtpdebugaddr;        /*!< Debug packets to/from this host */
133 static struct ast_sockaddr rtcpdebugaddr;       /*!< Debug RTCP packets to/from this host */
134 static int rtpdebugport;                /*< Debug only RTP packets from IP or IP+Port if port is > 0 */
135 static int rtcpdebugport;               /*< Debug only RTCP packets from IP or IP+Port if port is > 0 */
136 #ifdef SO_NO_CHECK
137 static int nochecksums;
138 #endif
139 static int strictrtp = DEFAULT_STRICT_RTP; /*< Only accept RTP frames from a defined source. If we receive an indication of a changing source, enter learning mode. */
140 static int learning_min_sequential = DEFAULT_LEARNING_MIN_SEQUENTIAL; /*< Number of sequential RTP frames needed from a single source during learning mode to accept new source. */
141 #ifdef HAVE_PJPROJECT
142 static int icesupport = DEFAULT_ICESUPPORT;
143 static struct sockaddr_in stunaddr;
144 static pj_str_t turnaddr;
145 static int turnport = DEFAULT_TURN_PORT;
146 static pj_str_t turnusername;
147 static pj_str_t turnpassword;
148
149 /*! \brief Pool factory used by pjlib to allocate memory. */
150 static pj_caching_pool cachingpool;
151
152 /*! \brief Global memory pool for configuration and timers */
153 static pj_pool_t *pool;
154
155 /*! \brief Global timer heap */
156 static pj_timer_heap_t *timer_heap;
157
158 /*! \brief Thread executing the timer heap */
159 static pj_thread_t *timer_thread;
160
161 /*! \brief Used to tell the timer thread to terminate */
162 static int timer_terminate;
163
164 /*! \brief Structure which contains ioqueue thread information */
165 struct ast_rtp_ioqueue_thread {
166         /*! \brief Pool used by the thread */
167         pj_pool_t *pool;
168         /*! \brief The thread handling the queue and timer heap */
169         pj_thread_t *thread;
170         /*! \brief Ioqueue which polls on sockets */
171         pj_ioqueue_t *ioqueue;
172         /*! \brief Timer heap for scheduled items */
173         pj_timer_heap_t *timerheap;
174         /*! \brief Termination request */
175         int terminate;
176         /*! \brief Current number of descriptors being waited on */
177         unsigned int count;
178         /*! \brief Linked list information */
179         AST_LIST_ENTRY(ast_rtp_ioqueue_thread) next;
180 };
181
182 /*! \brief List of ioqueue threads */
183 static AST_LIST_HEAD_STATIC(ioqueues, ast_rtp_ioqueue_thread);
184
185 #endif
186
187 #define FLAG_3389_WARNING               (1 << 0)
188 #define FLAG_NAT_ACTIVE                 (3 << 1)
189 #define FLAG_NAT_INACTIVE               (0 << 1)
190 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
191 #define FLAG_NEED_MARKER_BIT            (1 << 3)
192 #define FLAG_DTMF_COMPENSATE            (1 << 4)
193
194 #define TRANSPORT_SOCKET_RTP 0
195 #define TRANSPORT_SOCKET_RTCP 1
196 #define TRANSPORT_TURN_RTP 2
197 #define TRANSPORT_TURN_RTCP 3
198
199 /*! \brief RTP learning mode tracking information */
200 struct rtp_learning_info {
201         int max_seq;    /*!< The highest sequence number received */
202         int packets;    /*!< The number of remaining packets before the source is accepted */
203 };
204
205 #ifdef HAVE_OPENSSL_SRTP
206 struct dtls_details {
207         ast_mutex_t lock; /*!< Lock for timeout timer synchronization */
208         SSL *ssl;         /*!< SSL session */
209         BIO *read_bio;    /*!< Memory buffer for reading */
210         BIO *write_bio;   /*!< Memory buffer for writing */
211         enum ast_rtp_dtls_setup dtls_setup; /*!< Current setup state */
212         enum ast_rtp_dtls_connection connection; /*!< Whether this is a new or existing connection */
213         int timeout_timer; /*!< Scheduler id for timeout timer */
214 };
215 #endif
216
217 /*! \brief RTP session description */
218 struct ast_rtp {
219         int s;
220         struct ast_frame f;
221         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
222         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
223         unsigned int themssrc;          /*!< Their SSRC */
224         unsigned int rxssrc;
225         unsigned int lastts;
226         unsigned int lastrxts;
227         unsigned int lastividtimestamp;
228         unsigned int lastovidtimestamp;
229         unsigned int lastitexttimestamp;
230         unsigned int lastotexttimestamp;
231         unsigned int lasteventseqn;
232         int lastrxseqno;                /*!< Last received sequence number */
233         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
234         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
235         unsigned int rxcount;           /*!< How many packets have we received? */
236         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
237         unsigned int txcount;           /*!< How many packets have we sent? */
238         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
239         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
240         double rxjitter;                /*!< Interarrival jitter at the moment in seconds */
241         double rxtransit;               /*!< Relative transit time for previous packet */
242         struct ast_format *lasttxformat;
243         struct ast_format *lastrxformat;
244
245         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
246         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
247         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
248
249         /* DTMF Reception Variables */
250         char resp;                        /*!< The current digit being processed */
251         unsigned int last_seqno;          /*!< The last known sequence number for any DTMF packet */
252         unsigned int last_end_timestamp;  /*!< The last known timestamp received from an END packet */
253         unsigned int dtmf_duration;       /*!< Total duration in samples since the digit start event */
254         unsigned int dtmf_timeout;        /*!< When this timestamp is reached we consider END frame lost and forcibly abort digit */
255         unsigned int dtmfsamples;
256         enum ast_rtp_dtmf_mode dtmfmode;  /*!< The current DTMF mode of the RTP stream */
257         /* DTMF Transmission Variables */
258         unsigned int lastdigitts;
259         char sending_digit;     /*!< boolean - are we sending digits */
260         char send_digit;        /*!< digit we are sending */
261         int send_payload;
262         int send_duration;
263         unsigned int flags;
264         struct timeval rxcore;
265         struct timeval txcore;
266         double drxcore;                 /*!< The double representation of the first received packet */
267         struct timeval lastrx;          /*!< timeval when we last received a packet */
268         struct timeval dtmfmute;
269         struct ast_smoother *smoother;
270         int *ioid;
271         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
272         unsigned short rxseqno;
273         struct ast_sched_context *sched;
274         struct io_context *io;
275         void *data;
276         struct ast_rtcp *rtcp;
277         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
278
279         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
280         struct ast_sockaddr strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
281
282         /*
283          * Learning mode values based on pjmedia's probation mode.  Many of these values are redundant to the above,
284          * but these are in place to keep learning mode sequence values sealed from their normal counterparts.
285          */
286         struct rtp_learning_info rtp_source_learn;      /* Learning mode track for the expected RTP source */
287         struct rtp_learning_info alt_source_learn;      /* Learning mode tracking for a new RTP source after one has been chosen */
288
289         struct rtp_red *red;
290
291         ast_mutex_t lock;           /*!< Lock for synchronization purposes */
292         ast_cond_t cond;            /*!< Condition for signaling */
293
294 #ifdef HAVE_PJPROJECT
295         pj_ice_sess *ice;           /*!< ICE session */
296         pj_turn_sock *turn_rtp;     /*!< RTP TURN relay */
297         pj_turn_sock *turn_rtcp;    /*!< RTCP TURN relay */
298         pj_turn_state_t turn_state; /*!< Current state of the TURN relay session */
299         unsigned int passthrough:1; /*!< Bit to indicate that the received packet should be passed through */
300         unsigned int rtp_passthrough:1; /*!< Bit to indicate that TURN RTP should be passed through */
301         unsigned int rtcp_passthrough:1; /*!< Bit to indicate that TURN RTCP should be passed through */
302         unsigned int ice_port;      /*!< Port that ICE was started with if it was previously started */
303         struct ast_sockaddr rtp_loop; /*!< Loopback address for forwarding RTP from TURN */
304         struct ast_sockaddr rtcp_loop; /*!< Loopback address for forwarding RTCP from TURN */
305
306         struct ast_rtp_ioqueue_thread *ioqueue; /*!< The ioqueue thread handling us */
307
308         char remote_ufrag[256];  /*!< The remote ICE username */
309         char remote_passwd[256]; /*!< The remote ICE password */
310
311         char local_ufrag[256];  /*!< The local ICE username */
312         char local_passwd[256]; /*!< The local ICE password */
313
314         struct ao2_container *ice_local_candidates;           /*!< The local ICE candidates */
315         struct ao2_container *ice_active_remote_candidates;   /*!< The remote ICE candidates */
316         struct ao2_container *ice_proposed_remote_candidates; /*!< Incoming remote ICE candidates for new session */
317         struct ast_sockaddr ice_original_rtp_addr;            /*!< rtp address that ICE started on first session */
318 #endif
319
320 #ifdef HAVE_OPENSSL_SRTP
321         SSL_CTX *ssl_ctx; /*!< SSL context */
322         enum ast_rtp_dtls_verify dtls_verify; /*!< What to verify */
323         enum ast_srtp_suite suite;   /*!< SRTP crypto suite */
324         enum ast_rtp_dtls_hash local_hash; /*!< Local hash used for the fingerprint */
325         char local_fingerprint[160]; /*!< Fingerprint of our certificate */
326         enum ast_rtp_dtls_hash remote_hash; /*!< Remote hash used for the fingerprint */
327         unsigned char remote_fingerprint[EVP_MAX_MD_SIZE]; /*!< Fingerprint of the peer certificate */
328         unsigned int rekey; /*!< Interval at which to renegotiate and rekey */
329         int rekeyid; /*!< Scheduled item id for rekeying */
330         struct dtls_details dtls; /*!< DTLS state information */
331 #endif
332 };
333
334 /*!
335  * \brief Structure defining an RTCP session.
336  *
337  * The concept "RTCP session" is not defined in RFC 3550, but since
338  * this structure is analogous to ast_rtp, which tracks a RTP session,
339  * it is logical to think of this as a RTCP session.
340  *
341  * RTCP packet is defined on page 9 of RFC 3550.
342  *
343  */
344 struct ast_rtcp {
345         int rtcp_info;
346         int s;                          /*!< Socket */
347         struct ast_sockaddr us;         /*!< Socket representation of the local endpoint. */
348         struct ast_sockaddr them;       /*!< Socket representation of the remote endpoint. */
349         unsigned int soc;               /*!< What they told us */
350         unsigned int spc;               /*!< What they told us */
351         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
352         struct timeval rxlsr;           /*!< Time when we got their last SR */
353         struct timeval txlsr;           /*!< Time when we sent or last SR*/
354         unsigned int expected_prior;    /*!< no. packets in previous interval */
355         unsigned int received_prior;    /*!< no. packets received in previous interval */
356         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
357         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
358         unsigned int sr_count;          /*!< number of SRs we've sent */
359         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
360         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
361         double rtt;                     /*!< Last reported rtt */
362         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
363         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
364
365         double reported_maxjitter;
366         double reported_minjitter;
367         double reported_normdev_jitter;
368         double reported_stdev_jitter;
369         unsigned int reported_jitter_count;
370
371         double reported_maxlost;
372         double reported_minlost;
373         double reported_normdev_lost;
374         double reported_stdev_lost;
375
376         double rxlost;
377         double maxrxlost;
378         double minrxlost;
379         double normdev_rxlost;
380         double stdev_rxlost;
381         unsigned int rxlost_count;
382
383         double maxrxjitter;
384         double minrxjitter;
385         double normdev_rxjitter;
386         double stdev_rxjitter;
387         unsigned int rxjitter_count;
388         double maxrtt;
389         double minrtt;
390         double normdevrtt;
391         double stdevrtt;
392         unsigned int rtt_count;
393
394         /* VP8: sequence number for the RTCP FIR FCI */
395         int firseq;
396
397 #ifdef HAVE_OPENSSL_SRTP
398         struct dtls_details dtls; /*!< DTLS state information */
399 #endif
400 };
401
402 struct rtp_red {
403         struct ast_frame t140;  /*!< Primary data  */
404         struct ast_frame t140red;   /*!< Redundant t140*/
405         unsigned char pt[AST_RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
406         unsigned char ts[AST_RED_MAX_GENERATION]; /*!< Time stamps */
407         unsigned char len[AST_RED_MAX_GENERATION]; /*!< length of each generation */
408         int num_gen; /*!< Number of generations */
409         int schedid; /*!< Timer id */
410         int ti; /*!< How long to buffer data before send */
411         unsigned char t140red_data[64000];
412         unsigned char buf_data[64000]; /*!< buffered primary data */
413         int hdrlen;
414         long int prev_ts;
415 };
416
417 AST_LIST_HEAD_NOLOCK(frame_list, ast_frame);
418
419 /* Forward Declarations */
420 static int ast_rtp_new(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *addr, void *data);
421 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
422 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
423 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
424 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration);
425 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode);
426 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance);
427 static void ast_rtp_update_source(struct ast_rtp_instance *instance);
428 static void ast_rtp_change_source(struct ast_rtp_instance *instance);
429 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
430 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp);
431 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
432 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp);
433 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr);
434 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
435 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
436 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
437 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
438 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
439 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username);
440 static void ast_rtp_stop(struct ast_rtp_instance *instance);
441 static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char* desc);
442 static int ast_rtp_sendcng(struct ast_rtp_instance *instance, int level);
443
444 #ifdef HAVE_OPENSSL_SRTP
445 static int ast_rtp_activate(struct ast_rtp_instance *instance);
446 static void dtls_srtp_check_pending(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp);
447 static void dtls_srtp_start_timeout_timer(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp);
448 static void dtls_srtp_stop_timeout_timer(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp);
449 #endif
450
451 static int __rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp, int *ice, int use_srtp);
452
453 #ifdef HAVE_PJPROJECT
454 /*! \brief Helper function which updates an ast_sockaddr with the candidate used for the component */
455 static void update_address_with_ice_candidate(struct ast_rtp *rtp, enum ast_rtp_ice_component_type component,
456         struct ast_sockaddr *cand_address)
457 {
458         char address[PJ_INET6_ADDRSTRLEN];
459
460         if (!rtp->ice || (component < 1) || !rtp->ice->comp[component - 1].valid_check) {
461                 return;
462         }
463
464         ast_sockaddr_parse(cand_address, pj_sockaddr_print(&rtp->ice->comp[component - 1].valid_check->rcand->addr, address, sizeof(address), 0), 0);
465         ast_sockaddr_set_port(cand_address, pj_sockaddr_get_port(&rtp->ice->comp[component - 1].valid_check->rcand->addr));
466 }
467
468 /*! \brief Destructor for locally created ICE candidates */
469 static void ast_rtp_ice_candidate_destroy(void *obj)
470 {
471         struct ast_rtp_engine_ice_candidate *candidate = obj;
472
473         if (candidate->foundation) {
474                 ast_free(candidate->foundation);
475         }
476
477         if (candidate->transport) {
478                 ast_free(candidate->transport);
479         }
480 }
481
482 static void ast_rtp_ice_set_authentication(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
483 {
484         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
485
486         if (!ast_strlen_zero(ufrag)) {
487                 ast_copy_string(rtp->remote_ufrag, ufrag, sizeof(rtp->remote_ufrag));
488         }
489
490         if (!ast_strlen_zero(password)) {
491                 ast_copy_string(rtp->remote_passwd, password, sizeof(rtp->remote_passwd));
492         }
493 }
494
495 static int ice_candidate_cmp(void *obj, void *arg, int flags)
496 {
497         struct ast_rtp_engine_ice_candidate *candidate1 = obj, *candidate2 = arg;
498
499         if (strcmp(candidate1->foundation, candidate2->foundation) ||
500                         candidate1->id != candidate2->id ||
501                         ast_sockaddr_cmp(&candidate1->address, &candidate2->address) ||
502                         candidate1->type != candidate1->type) {
503                 return 0;
504         }
505
506         return CMP_MATCH | CMP_STOP;
507 }
508
509 static void ast_rtp_ice_add_remote_candidate(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
510 {
511         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
512         struct ast_rtp_engine_ice_candidate *remote_candidate;
513
514         /* ICE sessions only support UDP candidates */
515         if (strcasecmp(candidate->transport, "udp")) {
516                 return;
517         }
518
519         if (!rtp->ice_proposed_remote_candidates &&
520                         !(rtp->ice_proposed_remote_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) {
521                 return;
522         }
523
524         /* If this is going to exceed the maximum number of ICE candidates don't even add it */
525         if (ao2_container_count(rtp->ice_proposed_remote_candidates) == PJ_ICE_MAX_CAND) {
526                 return;
527         }
528
529         if (!(remote_candidate = ao2_alloc(sizeof(*remote_candidate), ast_rtp_ice_candidate_destroy))) {
530                 return;
531         }
532
533         remote_candidate->foundation = ast_strdup(candidate->foundation);
534         remote_candidate->id = candidate->id;
535         remote_candidate->transport = ast_strdup(candidate->transport);
536         remote_candidate->priority = candidate->priority;
537         ast_sockaddr_copy(&remote_candidate->address, &candidate->address);
538         ast_sockaddr_copy(&remote_candidate->relay_address, &candidate->relay_address);
539         remote_candidate->type = candidate->type;
540
541         ao2_link(rtp->ice_proposed_remote_candidates, remote_candidate);
542         ao2_ref(remote_candidate, -1);
543 }
544
545 AST_THREADSTORAGE(pj_thread_storage);
546
547 /*! \brief Function used to check if the calling thread is registered with pjlib. If it is not it will be registered. */
548 static void pj_thread_register_check(void)
549 {
550         pj_thread_desc *desc;
551         pj_thread_t *thread;
552
553         if (pj_thread_is_registered() == PJ_TRUE) {
554                 return;
555         }
556
557         desc = ast_threadstorage_get(&pj_thread_storage, sizeof(pj_thread_desc));
558         if (!desc) {
559                 ast_log(LOG_ERROR, "Could not get thread desc from thread-local storage. Expect awful things to occur\n");
560                 return;
561         }
562         pj_bzero(*desc, sizeof(*desc));
563
564         if (pj_thread_register("Asterisk Thread", *desc, &thread) != PJ_SUCCESS) {
565                 ast_log(LOG_ERROR, "Coudln't register thread with PJLIB.\n");
566         }
567         return;
568 }
569
570 static int ice_create(struct ast_rtp_instance *instance, struct ast_sockaddr *addr,
571         int port, int replace);
572
573 static void ast_rtp_ice_stop(struct ast_rtp_instance *instance)
574 {
575         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
576
577         if (!rtp->ice) {
578                 return;
579         }
580
581         pj_thread_register_check();
582
583         pj_ice_sess_destroy(rtp->ice);
584         rtp->ice = NULL;
585 }
586
587 static int ice_reset_session(struct ast_rtp_instance *instance)
588 {
589         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
590         pj_ice_sess_role role = rtp->ice->role;
591         int res;
592
593         ast_debug(3, "Resetting ICE for RTP instance '%p'\n", instance);
594         if (!rtp->ice->is_nominating && !rtp->ice->is_complete) {
595                 ast_debug(3, "Nevermind. ICE isn't ready for a reset\n");
596                 return 0;
597         }
598
599         ast_debug(3, "Stopping ICE for RTP instance '%p'\n", instance);
600         ast_rtp_ice_stop(instance);
601
602         ast_debug(3, "Recreating ICE session %s (%d) for RTP instance '%p'\n", ast_sockaddr_stringify(&rtp->ice_original_rtp_addr), rtp->ice_port, instance);
603         res = ice_create(instance, &rtp->ice_original_rtp_addr, rtp->ice_port, 1);
604         if (!res) {
605                 /* Preserve the role that the old ICE session used */
606                 pj_ice_sess_change_role(rtp->ice, role);
607         }
608
609         return res;
610 }
611
612 static int ice_candidates_compare(struct ao2_container *left, struct ao2_container *right)
613 {
614         struct ao2_iterator i;
615         struct ast_rtp_engine_ice_candidate *right_candidate;
616
617         if (ao2_container_count(left) != ao2_container_count(right)) {
618                 return -1;
619         }
620
621         i = ao2_iterator_init(right, 0);
622         while ((right_candidate = ao2_iterator_next(&i))) {
623                 struct ast_rtp_engine_ice_candidate *left_candidate = ao2_find(left, right_candidate, OBJ_POINTER);
624
625                 if (!left_candidate) {
626                         ao2_ref(right_candidate, -1);
627                         ao2_iterator_destroy(&i);
628                         return -1;
629                 }
630
631                 ao2_ref(left_candidate, -1);
632                 ao2_ref(right_candidate, -1);
633         }
634         ao2_iterator_destroy(&i);
635
636         return 0;
637 }
638
639 static void ast_rtp_ice_start(struct ast_rtp_instance *instance)
640 {
641         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
642         pj_str_t ufrag = pj_str(rtp->remote_ufrag), passwd = pj_str(rtp->remote_passwd);
643         pj_ice_sess_cand candidates[PJ_ICE_MAX_CAND];
644         struct ao2_iterator i;
645         struct ast_rtp_engine_ice_candidate *candidate;
646         int cand_cnt = 0, has_rtp = 0, has_rtcp = 0;
647
648         if (!rtp->ice || !rtp->ice_proposed_remote_candidates) {
649                 return;
650         }
651
652         /* Check for equivalence in the lists */
653         if (rtp->ice_active_remote_candidates &&
654                         !ice_candidates_compare(rtp->ice_proposed_remote_candidates, rtp->ice_active_remote_candidates)) {
655                 ast_debug(3, "Proposed == active candidates for RTP instance '%p'\n", instance);
656                 ao2_cleanup(rtp->ice_proposed_remote_candidates);
657                 rtp->ice_proposed_remote_candidates = NULL;
658                 return;
659         }
660
661         /* Out with the old, in with the new */
662         ao2_cleanup(rtp->ice_active_remote_candidates);
663         rtp->ice_active_remote_candidates = rtp->ice_proposed_remote_candidates;
664         rtp->ice_proposed_remote_candidates = NULL;
665
666         /* Reset the ICE session. Is this going to work? */
667         if (ice_reset_session(instance)) {
668                 ast_log(LOG_NOTICE, "Failed to create replacement ICE session\n");
669                 return;
670         }
671
672         pj_thread_register_check();
673
674         i = ao2_iterator_init(rtp->ice_active_remote_candidates, 0);
675
676         while ((candidate = ao2_iterator_next(&i)) && (cand_cnt < PJ_ICE_MAX_CAND)) {
677                 pj_str_t address;
678
679                 /* there needs to be at least one rtp and rtcp candidate in the list */
680                 has_rtp |= candidate->id == AST_RTP_ICE_COMPONENT_RTP;
681                 has_rtcp |= candidate->id == AST_RTP_ICE_COMPONENT_RTCP;
682
683                 pj_strdup2(rtp->ice->pool, &candidates[cand_cnt].foundation, candidate->foundation);
684                 candidates[cand_cnt].comp_id = candidate->id;
685                 candidates[cand_cnt].prio = candidate->priority;
686
687                 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&address, ast_sockaddr_stringify(&candidate->address)), &candidates[cand_cnt].addr);
688
689                 if (!ast_sockaddr_isnull(&candidate->relay_address)) {
690                         pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&address, ast_sockaddr_stringify(&candidate->relay_address)), &candidates[cand_cnt].rel_addr);
691                 }
692
693                 if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
694                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_HOST;
695                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
696                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_SRFLX;
697                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_RELAYED) {
698                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_RELAYED;
699                 }
700
701                 if (candidate->id == AST_RTP_ICE_COMPONENT_RTP && rtp->turn_rtp) {
702                         ast_debug(3, "RTP candidate %s (%p)\n", ast_sockaddr_stringify(&candidate->address), instance);
703                         pj_turn_sock_set_perm(rtp->turn_rtp, 1, &candidates[cand_cnt].addr, 1);
704                 } else if (candidate->id == AST_RTP_ICE_COMPONENT_RTCP && rtp->turn_rtcp) {
705                         ast_debug(3, "RTCP candidate %s (%p)\n", ast_sockaddr_stringify(&candidate->address), instance);
706                         pj_turn_sock_set_perm(rtp->turn_rtcp, 1, &candidates[cand_cnt].addr, 1);
707                 }
708
709                 cand_cnt++;
710                 ao2_ref(candidate, -1);
711         }
712
713         ao2_iterator_destroy(&i);
714
715         if (cand_cnt < ao2_container_count(rtp->ice_active_remote_candidates)) {
716                 ast_log(LOG_WARNING, "Lost %d ICE candidates. Consider increasing PJ_ICE_MAX_CAND in PJSIP (%p)\n",
717                         ao2_container_count(rtp->ice_active_remote_candidates) - cand_cnt, instance);
718         }
719
720         if (!has_rtp) {
721                 ast_log(LOG_WARNING, "No RTP candidates; skipping ICE checklist (%p)\n", instance);
722         }
723
724         if (!has_rtcp) {
725                 ast_log(LOG_WARNING, "No RTCP candidates; skipping ICE checklist (%p)\n", instance);
726         }
727
728         if (has_rtp && has_rtcp) {
729                 pj_status_t res = pj_ice_sess_create_check_list(rtp->ice, &ufrag, &passwd, cand_cnt, &candidates[0]);
730                 char reason[80];
731
732                 if (res == PJ_SUCCESS) {
733                         ast_debug(3, "Successfully created ICE checklist (%p)\n", instance);
734                         ast_test_suite_event_notify("ICECHECKLISTCREATE", "Result: SUCCESS");
735                         pj_ice_sess_start_check(rtp->ice);
736                         pj_timer_heap_poll(timer_heap, NULL);
737                         rtp->strict_rtp_state = STRICT_RTP_OPEN;
738                         return;
739                 }
740
741                 pj_strerror(res, reason, sizeof(reason));
742                 ast_log(LOG_WARNING, "Failed to create ICE session check list: %s (%p)\n", reason, instance);
743         }
744
745         ast_test_suite_event_notify("ICECHECKLISTCREATE", "Result: FAILURE");
746
747         /* even though create check list failed don't stop ice as
748            it might still work */
749         /* however we do need to reset remote candidates since
750            this function may be re-entered */
751         ao2_ref(rtp->ice_active_remote_candidates, -1);
752         rtp->ice_active_remote_candidates = NULL;
753         rtp->ice->rcand_cnt = rtp->ice->clist.count = 0;
754 }
755
756 static const char *ast_rtp_ice_get_ufrag(struct ast_rtp_instance *instance)
757 {
758         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
759
760         return rtp->local_ufrag;
761 }
762
763 static const char *ast_rtp_ice_get_password(struct ast_rtp_instance *instance)
764 {
765         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
766
767         return rtp->local_passwd;
768 }
769
770 static struct ao2_container *ast_rtp_ice_get_local_candidates(struct ast_rtp_instance *instance)
771 {
772         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
773
774         if (rtp->ice_local_candidates) {
775                 ao2_ref(rtp->ice_local_candidates, +1);
776         }
777
778         return rtp->ice_local_candidates;
779 }
780
781 static void ast_rtp_ice_lite(struct ast_rtp_instance *instance)
782 {
783         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
784
785         if (!rtp->ice) {
786                 return;
787         }
788
789         pj_thread_register_check();
790
791         pj_ice_sess_change_role(rtp->ice, PJ_ICE_SESS_ROLE_CONTROLLING);
792 }
793
794 static void ast_rtp_ice_set_role(struct ast_rtp_instance *instance, enum ast_rtp_ice_role role)
795 {
796         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
797
798         ast_debug(3, "Set role to %s (%p)\n",
799                 role == AST_RTP_ICE_ROLE_CONTROLLED ? "CONTROLLED" : "CONTROLLING", instance);
800
801         if (!rtp->ice) {
802                 ast_debug(3, "Set role failed; no ice instance (%p)\n", instance);
803                 return;
804         }
805
806         pj_thread_register_check();
807
808         pj_ice_sess_change_role(rtp->ice, role == AST_RTP_ICE_ROLE_CONTROLLED ?
809                 PJ_ICE_SESS_ROLE_CONTROLLED : PJ_ICE_SESS_ROLE_CONTROLLING);
810 }
811
812 static void ast_rtp_ice_add_cand(struct ast_rtp *rtp, unsigned comp_id, unsigned transport_id, pj_ice_cand_type type, pj_uint16_t local_pref,
813                                         const pj_sockaddr_t *addr, const pj_sockaddr_t *base_addr, const pj_sockaddr_t *rel_addr, int addr_len)
814 {
815         pj_str_t foundation;
816         struct ast_rtp_engine_ice_candidate *candidate, *existing;
817         char address[PJ_INET6_ADDRSTRLEN];
818
819         pj_thread_register_check();
820
821         pj_ice_calc_foundation(rtp->ice->pool, &foundation, type, addr);
822
823         if (!rtp->ice_local_candidates && !(rtp->ice_local_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) {
824                 return;
825         }
826
827         if (!(candidate = ao2_alloc(sizeof(*candidate), ast_rtp_ice_candidate_destroy))) {
828                 return;
829         }
830
831         candidate->foundation = ast_strndup(pj_strbuf(&foundation), pj_strlen(&foundation));
832         candidate->id = comp_id;
833         candidate->transport = ast_strdup("UDP");
834
835         ast_sockaddr_parse(&candidate->address, pj_sockaddr_print(addr, address, sizeof(address), 0), 0);
836         ast_sockaddr_set_port(&candidate->address, pj_sockaddr_get_port(addr));
837
838         if (rel_addr) {
839                 ast_sockaddr_parse(&candidate->relay_address, pj_sockaddr_print(rel_addr, address, sizeof(address), 0), 0);
840                 ast_sockaddr_set_port(&candidate->relay_address, pj_sockaddr_get_port(rel_addr));
841         }
842
843         if (type == PJ_ICE_CAND_TYPE_HOST) {
844                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
845         } else if (type == PJ_ICE_CAND_TYPE_SRFLX) {
846                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
847         } else if (type == PJ_ICE_CAND_TYPE_RELAYED) {
848                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
849         }
850
851         if ((existing = ao2_find(rtp->ice_local_candidates, candidate, OBJ_POINTER))) {
852                 ao2_ref(existing, -1);
853                 ao2_ref(candidate, -1);
854                 return;
855         }
856
857         if (pj_ice_sess_add_cand(rtp->ice, comp_id, transport_id, type, local_pref, &foundation, addr, base_addr, rel_addr, addr_len, NULL) != PJ_SUCCESS) {
858                 ao2_ref(candidate, -1);
859                 return;
860         }
861
862         /* By placing the candidate into the ICE session it will have produced the priority, so update the local candidate with it */
863         candidate->priority = rtp->ice->lcand[rtp->ice->lcand_cnt - 1].prio;
864
865         ao2_link(rtp->ice_local_candidates, candidate);
866         ao2_ref(candidate, -1);
867 }
868
869 static void ast_rtp_on_turn_rx_rtp_data(pj_turn_sock *turn_sock, void *pkt, unsigned pkt_len, const pj_sockaddr_t *peer_addr, unsigned addr_len)
870 {
871         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
872         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
873         pj_status_t status;
874
875         status = pj_ice_sess_on_rx_pkt(rtp->ice, AST_RTP_ICE_COMPONENT_RTP, TRANSPORT_TURN_RTP, pkt, pkt_len, peer_addr,
876                 addr_len);
877         if (status != PJ_SUCCESS) {
878                 char buf[100];
879
880                 pj_strerror(status, buf, sizeof(buf));
881                 ast_log(LOG_WARNING, "PJ ICE Rx error status code: %d '%s'.\n",
882                         (int)status, buf);
883                 return;
884         }
885         if (!rtp->rtp_passthrough) {
886                 return;
887         }
888         rtp->rtp_passthrough = 0;
889
890         ast_sendto(rtp->s, pkt, pkt_len, 0, &rtp->rtp_loop);
891 }
892
893 static void ast_rtp_on_turn_rtp_state(pj_turn_sock *turn_sock, pj_turn_state_t old_state, pj_turn_state_t new_state)
894 {
895         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
896         struct ast_rtp *rtp;
897
898         /* If this is a leftover from an already notified RTP instance just ignore the state change */
899         if (!instance) {
900                 return;
901         }
902
903         rtp = ast_rtp_instance_get_data(instance);
904
905         /* We store the new state so the other thread can actually handle it */
906         ast_mutex_lock(&rtp->lock);
907         rtp->turn_state = new_state;
908         ast_cond_signal(&rtp->cond);
909
910         if (new_state == PJ_TURN_STATE_DESTROYING) {
911                 pj_turn_sock_set_user_data(rtp->turn_rtp, NULL);
912                 rtp->turn_rtp = NULL;
913         }
914
915         ast_mutex_unlock(&rtp->lock);
916 }
917
918 /* RTP TURN Socket interface declaration */
919 static pj_turn_sock_cb ast_rtp_turn_rtp_sock_cb = {
920         .on_rx_data = ast_rtp_on_turn_rx_rtp_data,
921         .on_state = ast_rtp_on_turn_rtp_state,
922 };
923
924 static void ast_rtp_on_turn_rx_rtcp_data(pj_turn_sock *turn_sock, void *pkt, unsigned pkt_len, const pj_sockaddr_t *peer_addr, unsigned addr_len)
925 {
926         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
927         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
928         pj_status_t status;
929
930         status = pj_ice_sess_on_rx_pkt(rtp->ice, AST_RTP_ICE_COMPONENT_RTCP, TRANSPORT_TURN_RTCP, pkt, pkt_len, peer_addr,
931                 addr_len);
932         if (status != PJ_SUCCESS) {
933                 char buf[100];
934
935                 pj_strerror(status, buf, sizeof(buf));
936                 ast_log(LOG_WARNING, "PJ ICE Rx error status code: %d '%s'.\n",
937                         (int)status, buf);
938                 return;
939         }
940         if (!rtp->rtcp_passthrough) {
941                 return;
942         }
943         rtp->rtcp_passthrough = 0;
944
945         ast_sendto(rtp->rtcp->s, pkt, pkt_len, 0, &rtp->rtcp_loop);
946 }
947
948 static void ast_rtp_on_turn_rtcp_state(pj_turn_sock *turn_sock, pj_turn_state_t old_state, pj_turn_state_t new_state)
949 {
950         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
951         struct ast_rtp *rtp = NULL;
952
953         /* If this is a leftover from an already destroyed RTP instance just ignore the state change */
954         if (!instance) {
955                 return;
956         }
957
958         rtp = ast_rtp_instance_get_data(instance);
959
960         /* We store the new state so the other thread can actually handle it */
961         ast_mutex_lock(&rtp->lock);
962         rtp->turn_state = new_state;
963         ast_cond_signal(&rtp->cond);
964
965         if (new_state == PJ_TURN_STATE_DESTROYING) {
966                 pj_turn_sock_set_user_data(rtp->turn_rtcp, NULL);
967                 rtp->turn_rtcp = NULL;
968         }
969
970         ast_mutex_unlock(&rtp->lock);
971 }
972
973 /* RTCP TURN Socket interface declaration */
974 static pj_turn_sock_cb ast_rtp_turn_rtcp_sock_cb = {
975         .on_rx_data = ast_rtp_on_turn_rx_rtcp_data,
976         .on_state = ast_rtp_on_turn_rtcp_state,
977 };
978
979 /*! \brief Worker thread for ioqueue and timerheap */
980 static int ioqueue_worker_thread(void *data)
981 {
982         struct ast_rtp_ioqueue_thread *ioqueue = data;
983
984         while (!ioqueue->terminate) {
985                 const pj_time_val delay = {0, 10};
986
987                 pj_ioqueue_poll(ioqueue->ioqueue, &delay);
988
989                 pj_timer_heap_poll(ioqueue->timerheap, NULL);
990         }
991
992         return 0;
993 }
994
995 /*! \brief Destroyer for ioqueue thread */
996 static void rtp_ioqueue_thread_destroy(struct ast_rtp_ioqueue_thread *ioqueue)
997 {
998         if (ioqueue->thread) {
999                 ioqueue->terminate = 1;
1000                 pj_thread_join(ioqueue->thread);
1001                 pj_thread_destroy(ioqueue->thread);
1002         }
1003
1004         pj_pool_release(ioqueue->pool);
1005         ast_free(ioqueue);
1006 }
1007
1008 /*! \brief Removal function for ioqueue thread, determines if it should be terminated and destroyed */
1009 static void rtp_ioqueue_thread_remove(struct ast_rtp_ioqueue_thread *ioqueue)
1010 {
1011         int destroy = 0;
1012
1013         /* If nothing is using this ioqueue thread destroy it */
1014         AST_LIST_LOCK(&ioqueues);
1015         if ((ioqueue->count - 2) == 0) {
1016                 destroy = 1;
1017                 AST_LIST_REMOVE(&ioqueues, ioqueue, next);
1018         }
1019         AST_LIST_UNLOCK(&ioqueues);
1020
1021         if (!destroy) {
1022                 return;
1023         }
1024
1025         rtp_ioqueue_thread_destroy(ioqueue);
1026 }
1027
1028 /*! \brief Finder and allocator for an ioqueue thread */
1029 static struct ast_rtp_ioqueue_thread *rtp_ioqueue_thread_get_or_create(void)
1030 {
1031         struct ast_rtp_ioqueue_thread *ioqueue;
1032         pj_lock_t *lock;
1033
1034         AST_LIST_LOCK(&ioqueues);
1035
1036         /* See if an ioqueue thread exists that can handle more */
1037         AST_LIST_TRAVERSE(&ioqueues, ioqueue, next) {
1038                 if ((ioqueue->count + 2) < PJ_IOQUEUE_MAX_HANDLES) {
1039                         break;
1040                 }
1041         }
1042
1043         /* If we found one bump it up and return it */
1044         if (ioqueue) {
1045                 ioqueue->count += 2;
1046                 goto end;
1047         }
1048
1049         ioqueue = ast_calloc(1, sizeof(*ioqueue));
1050         if (!ioqueue) {
1051                 goto end;
1052         }
1053
1054         ioqueue->pool = pj_pool_create(&cachingpool.factory, "rtp", 512, 512, NULL);
1055
1056         /* We use a timer on the ioqueue thread for TURN so that two threads aren't operating
1057          * on a session at the same time
1058          */
1059         if (pj_timer_heap_create(ioqueue->pool, 4, &ioqueue->timerheap) != PJ_SUCCESS) {
1060                 goto fatal;
1061         }
1062
1063         if (pj_lock_create_recursive_mutex(ioqueue->pool, "rtp%p", &lock) != PJ_SUCCESS) {
1064                 goto fatal;
1065         }
1066
1067         pj_timer_heap_set_lock(ioqueue->timerheap, lock, PJ_TRUE);
1068
1069         if (pj_ioqueue_create(ioqueue->pool, PJ_IOQUEUE_MAX_HANDLES, &ioqueue->ioqueue) != PJ_SUCCESS) {
1070                 goto fatal;
1071         }
1072
1073         if (pj_thread_create(ioqueue->pool, "ice", &ioqueue_worker_thread, ioqueue, 0, 0, &ioqueue->thread) != PJ_SUCCESS) {
1074                 goto fatal;
1075         }
1076
1077         AST_LIST_INSERT_HEAD(&ioqueues, ioqueue, next);
1078
1079         /* Since this is being returned to an active session the count always starts at 2 */
1080         ioqueue->count = 2;
1081
1082         goto end;
1083
1084 fatal:
1085         rtp_ioqueue_thread_destroy(ioqueue);
1086         ioqueue = NULL;
1087
1088 end:
1089         AST_LIST_UNLOCK(&ioqueues);
1090         return ioqueue;
1091 }
1092
1093 static void ast_rtp_ice_turn_request(struct ast_rtp_instance *instance, enum ast_rtp_ice_component_type component,
1094                 enum ast_transport transport, const char *server, unsigned int port, const char *username, const char *password)
1095 {
1096         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1097         pj_turn_sock **turn_sock;
1098         const pj_turn_sock_cb *turn_cb;
1099         pj_turn_tp_type conn_type;
1100         int conn_transport;
1101         pj_stun_auth_cred cred = { 0, };
1102         pj_str_t turn_addr;
1103         struct ast_sockaddr addr = { { 0, } };
1104         pj_stun_config stun_config;
1105         struct timeval wait = ast_tvadd(ast_tvnow(), ast_samp2tv(TURN_STATE_WAIT_TIME, 1000));
1106         struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
1107         pj_turn_session_info info;
1108         struct ast_sockaddr local, loop;
1109
1110         ast_rtp_instance_get_local_address(instance, &local);
1111         if (ast_sockaddr_is_ipv4(&local)) {
1112                 ast_sockaddr_parse(&loop, "127.0.0.1", PARSE_PORT_FORBID);
1113         } else {
1114                 ast_sockaddr_parse(&loop, "::1", PARSE_PORT_FORBID);
1115         }
1116
1117         /* Determine what component we are requesting a TURN session for */
1118         if (component == AST_RTP_ICE_COMPONENT_RTP) {
1119                 turn_sock = &rtp->turn_rtp;
1120                 turn_cb = &ast_rtp_turn_rtp_sock_cb;
1121                 conn_transport = TRANSPORT_TURN_RTP;
1122                 ast_sockaddr_set_port(&loop, ast_sockaddr_port(&local));
1123         } else if (component == AST_RTP_ICE_COMPONENT_RTCP) {
1124                 turn_sock = &rtp->turn_rtcp;
1125                 turn_cb = &ast_rtp_turn_rtcp_sock_cb;
1126                 conn_transport = TRANSPORT_TURN_RTCP;
1127                 ast_sockaddr_set_port(&loop, ast_sockaddr_port(&rtp->rtcp->us));
1128         } else {
1129                 return;
1130         }
1131
1132         if (transport == AST_TRANSPORT_UDP) {
1133                 conn_type = PJ_TURN_TP_UDP;
1134         } else if (transport == AST_TRANSPORT_TCP) {
1135                 conn_type = PJ_TURN_TP_TCP;
1136         } else {
1137                 ast_assert(0);
1138                 return;
1139         }
1140
1141         ast_sockaddr_parse(&addr, server, PARSE_PORT_FORBID);
1142
1143         ast_mutex_lock(&rtp->lock);
1144         if (*turn_sock) {
1145                 pj_turn_sock_destroy(*turn_sock);
1146                 rtp->turn_state = PJ_TURN_STATE_NULL;
1147                 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
1148                         ast_cond_timedwait(&rtp->cond, &rtp->lock, &ts);
1149                 }
1150         }
1151         ast_mutex_unlock(&rtp->lock);
1152
1153         if (component == AST_RTP_ICE_COMPONENT_RTP && !rtp->ioqueue) {
1154                 rtp->ioqueue = rtp_ioqueue_thread_get_or_create();
1155                 if (!rtp->ioqueue) {
1156                         return;
1157                 }
1158         }
1159
1160         pj_stun_config_init(&stun_config, &cachingpool.factory, 0, rtp->ioqueue->ioqueue, rtp->ioqueue->timerheap);
1161
1162         if (pj_turn_sock_create(&stun_config, ast_sockaddr_is_ipv4(&addr) ? pj_AF_INET() : pj_AF_INET6(), conn_type,
1163                 turn_cb, NULL, instance, turn_sock) != PJ_SUCCESS) {
1164                 ast_log(LOG_WARNING, "Could not create a TURN client socket\n");
1165                 return;
1166         }
1167
1168         cred.type = PJ_STUN_AUTH_CRED_STATIC;
1169         pj_strset2(&cred.data.static_cred.username, (char*)username);
1170         cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
1171         pj_strset2(&cred.data.static_cred.data, (char*)password);
1172
1173         /* Because the TURN socket is asynchronous but we are synchronous we need to wait until it is done */
1174         ast_mutex_lock(&rtp->lock);
1175         pj_turn_sock_alloc(*turn_sock, pj_cstr(&turn_addr, server), port, NULL, &cred, NULL);
1176         while (rtp->turn_state < PJ_TURN_STATE_READY) {
1177                 ast_cond_timedwait(&rtp->cond, &rtp->lock, &ts);
1178         }
1179         ast_mutex_unlock(&rtp->lock);
1180
1181         /* If a TURN session was allocated add it as a candidate */
1182         if (rtp->turn_state != PJ_TURN_STATE_READY) {
1183                 return;
1184         }
1185
1186         pj_turn_sock_get_info(*turn_sock, &info);
1187
1188         ast_rtp_ice_add_cand(rtp, component, conn_transport, PJ_ICE_CAND_TYPE_RELAYED, 65535, &info.relay_addr,
1189                 &info.relay_addr, &info.mapped_addr, pj_sockaddr_get_len(&info.relay_addr));
1190
1191         if (component == AST_RTP_ICE_COMPONENT_RTP) {
1192                 ast_sockaddr_copy(&rtp->rtp_loop, &loop);
1193         } else if (component == AST_RTP_ICE_COMPONENT_RTCP) {
1194                 ast_sockaddr_copy(&rtp->rtcp_loop, &loop);
1195         }
1196 }
1197
1198 static char *generate_random_string(char *buf, size_t size)
1199 {
1200         long val[4];
1201         int x;
1202
1203         for (x=0; x<4; x++) {
1204                 val[x] = ast_random();
1205         }
1206         snprintf(buf, size, "%08lx%08lx%08lx%08lx", (long unsigned)val[0], (long unsigned)val[1], (long unsigned)val[2], (long unsigned)val[3]);
1207
1208         return buf;
1209 }
1210
1211 /* ICE RTP Engine interface declaration */
1212 static struct ast_rtp_engine_ice ast_rtp_ice = {
1213         .set_authentication = ast_rtp_ice_set_authentication,
1214         .add_remote_candidate = ast_rtp_ice_add_remote_candidate,
1215         .start = ast_rtp_ice_start,
1216         .stop = ast_rtp_ice_stop,
1217         .get_ufrag = ast_rtp_ice_get_ufrag,
1218         .get_password = ast_rtp_ice_get_password,
1219         .get_local_candidates = ast_rtp_ice_get_local_candidates,
1220         .ice_lite = ast_rtp_ice_lite,
1221         .set_role = ast_rtp_ice_set_role,
1222         .turn_request = ast_rtp_ice_turn_request,
1223 };
1224 #endif
1225
1226 #ifdef HAVE_OPENSSL_SRTP
1227 static int dtls_verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
1228 {
1229         /* We don't want to actually verify the certificate so just accept what they have provided */
1230         return 1;
1231 }
1232
1233 static int dtls_details_initialize(struct dtls_details *dtls, SSL_CTX *ssl_ctx,
1234         enum ast_rtp_dtls_setup setup)
1235 {
1236         dtls->dtls_setup = setup;
1237
1238         if (!(dtls->ssl = SSL_new(ssl_ctx))) {
1239                 ast_log(LOG_ERROR, "Failed to allocate memory for SSL\n");
1240                 goto error;
1241         }
1242
1243         if (!(dtls->read_bio = BIO_new(BIO_s_mem()))) {
1244                 ast_log(LOG_ERROR, "Failed to allocate memory for inbound SSL traffic\n");
1245                 goto error;
1246         }
1247         BIO_set_mem_eof_return(dtls->read_bio, -1);
1248
1249         if (!(dtls->write_bio = BIO_new(BIO_s_mem()))) {
1250                 ast_log(LOG_ERROR, "Failed to allocate memory for outbound SSL traffic\n");
1251                 goto error;
1252         }
1253         BIO_set_mem_eof_return(dtls->write_bio, -1);
1254
1255         SSL_set_bio(dtls->ssl, dtls->read_bio, dtls->write_bio);
1256
1257         if (dtls->dtls_setup == AST_RTP_DTLS_SETUP_PASSIVE) {
1258                 SSL_set_accept_state(dtls->ssl);
1259         } else {
1260                 SSL_set_connect_state(dtls->ssl);
1261         }
1262         dtls->connection = AST_RTP_DTLS_CONNECTION_NEW;
1263
1264         ast_mutex_init(&dtls->lock);
1265
1266         return 0;
1267
1268 error:
1269         if (dtls->read_bio) {
1270                 BIO_free(dtls->read_bio);
1271                 dtls->read_bio = NULL;
1272         }
1273
1274         if (dtls->write_bio) {
1275                 BIO_free(dtls->write_bio);
1276                 dtls->write_bio = NULL;
1277         }
1278
1279         if (dtls->ssl) {
1280                 SSL_free(dtls->ssl);
1281                 dtls->ssl = NULL;
1282         }
1283         return -1;
1284 }
1285
1286 static int dtls_setup_rtcp(struct ast_rtp_instance *instance)
1287 {
1288         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1289
1290         if (!rtp->ssl_ctx || !rtp->rtcp) {
1291                 return 0;
1292         }
1293
1294         return dtls_details_initialize(&rtp->rtcp->dtls, rtp->ssl_ctx, rtp->dtls.dtls_setup);
1295 }
1296
1297 static int ast_rtp_dtls_set_configuration(struct ast_rtp_instance *instance, const struct ast_rtp_dtls_cfg *dtls_cfg)
1298 {
1299         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1300         int res;
1301 #ifndef HAVE_OPENSSL_ECDH_AUTO
1302         EC_KEY *ecdh;
1303 #endif
1304
1305         if (!dtls_cfg->enabled) {
1306                 return 0;
1307         }
1308
1309         if (!ast_rtp_engine_srtp_is_registered()) {
1310                 ast_log(LOG_ERROR, "SRTP support module is not loaded or available. Try loading res_srtp.so.\n");
1311                 return -1;
1312         }
1313
1314         if (rtp->ssl_ctx) {
1315                 return 0;
1316         }
1317
1318         if (!(rtp->ssl_ctx = SSL_CTX_new(DTLSv1_method()))) {
1319                 return -1;
1320         }
1321
1322         SSL_CTX_set_read_ahead(rtp->ssl_ctx, 1);
1323
1324 #ifdef HAVE_OPENSSL_ECDH_AUTO
1325         SSL_CTX_set_ecdh_auto(rtp->ssl_ctx, 1);
1326 #else
1327         ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
1328         if (ecdh) {
1329                 SSL_CTX_set_tmp_ecdh(rtp->ssl_ctx, ecdh);
1330                 EC_KEY_free(ecdh);
1331         }
1332 #endif
1333
1334         rtp->dtls_verify = dtls_cfg->verify;
1335
1336         SSL_CTX_set_verify(rtp->ssl_ctx, (rtp->dtls_verify & AST_RTP_DTLS_VERIFY_FINGERPRINT) || (rtp->dtls_verify & AST_RTP_DTLS_VERIFY_CERTIFICATE) ?
1337                 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT : SSL_VERIFY_NONE, !(rtp->dtls_verify & AST_RTP_DTLS_VERIFY_CERTIFICATE) ?
1338                 dtls_verify_callback : NULL);
1339
1340         if (dtls_cfg->suite == AST_AES_CM_128_HMAC_SHA1_80) {
1341                 SSL_CTX_set_tlsext_use_srtp(rtp->ssl_ctx, "SRTP_AES128_CM_SHA1_80");
1342         } else if (dtls_cfg->suite == AST_AES_CM_128_HMAC_SHA1_32) {
1343                 SSL_CTX_set_tlsext_use_srtp(rtp->ssl_ctx, "SRTP_AES128_CM_SHA1_32");
1344         } else {
1345                 ast_log(LOG_ERROR, "Unsupported suite specified for DTLS-SRTP on RTP instance '%p'\n", instance);
1346                 return -1;
1347         }
1348
1349         rtp->local_hash = dtls_cfg->hash;
1350
1351         if (!ast_strlen_zero(dtls_cfg->certfile)) {
1352                 char *private = ast_strlen_zero(dtls_cfg->pvtfile) ? dtls_cfg->certfile : dtls_cfg->pvtfile;
1353                 BIO *certbio;
1354                 X509 *cert;
1355                 const EVP_MD *type;
1356                 unsigned int size, i;
1357                 unsigned char fingerprint[EVP_MAX_MD_SIZE];
1358                 char *local_fingerprint = rtp->local_fingerprint;
1359
1360                 if (!SSL_CTX_use_certificate_file(rtp->ssl_ctx, dtls_cfg->certfile, SSL_FILETYPE_PEM)) {
1361                         ast_log(LOG_ERROR, "Specified certificate file '%s' for RTP instance '%p' could not be used\n",
1362                                 dtls_cfg->certfile, instance);
1363                         return -1;
1364                 }
1365
1366                 if (!SSL_CTX_use_PrivateKey_file(rtp->ssl_ctx, private, SSL_FILETYPE_PEM) ||
1367                     !SSL_CTX_check_private_key(rtp->ssl_ctx)) {
1368                         ast_log(LOG_ERROR, "Specified private key file '%s' for RTP instance '%p' could not be used\n",
1369                                 private, instance);
1370                         return -1;
1371                 }
1372
1373                 if (!(certbio = BIO_new(BIO_s_file()))) {
1374                         ast_log(LOG_ERROR, "Failed to allocate memory for certificate fingerprinting on RTP instance '%p'\n",
1375                                 instance);
1376                         return -1;
1377                 }
1378
1379                 if (rtp->local_hash == AST_RTP_DTLS_HASH_SHA1) {
1380                         type = EVP_sha1();
1381                 } else if (rtp->local_hash == AST_RTP_DTLS_HASH_SHA256) {
1382                         type = EVP_sha256();
1383                 } else {
1384                         ast_log(LOG_ERROR, "Unsupported fingerprint hash type on RTP instance '%p'\n",
1385                                 instance);
1386                         return -1;
1387                 }
1388
1389                 if (!BIO_read_filename(certbio, dtls_cfg->certfile) ||
1390                     !(cert = PEM_read_bio_X509(certbio, NULL, 0, NULL)) ||
1391                     !X509_digest(cert, type, fingerprint, &size) ||
1392                     !size) {
1393                         ast_log(LOG_ERROR, "Could not produce fingerprint from certificate '%s' for RTP instance '%p'\n",
1394                                 dtls_cfg->certfile, instance);
1395                         BIO_free_all(certbio);
1396                         return -1;
1397                 }
1398
1399                 for (i = 0; i < size; i++) {
1400                         sprintf(local_fingerprint, "%02hhX:", fingerprint[i]);
1401                         local_fingerprint += 3;
1402                 }
1403
1404                 *(local_fingerprint-1) = 0;
1405
1406                 BIO_free_all(certbio);
1407         }
1408
1409         if (!ast_strlen_zero(dtls_cfg->cipher)) {
1410                 if (!SSL_CTX_set_cipher_list(rtp->ssl_ctx, dtls_cfg->cipher)) {
1411                         ast_log(LOG_ERROR, "Invalid cipher specified in cipher list '%s' for RTP instance '%p'\n",
1412                                 dtls_cfg->cipher, instance);
1413                         return -1;
1414                 }
1415         }
1416
1417         if (!ast_strlen_zero(dtls_cfg->cafile) || !ast_strlen_zero(dtls_cfg->capath)) {
1418                 if (!SSL_CTX_load_verify_locations(rtp->ssl_ctx, S_OR(dtls_cfg->cafile, NULL), S_OR(dtls_cfg->capath, NULL))) {
1419                         ast_log(LOG_ERROR, "Invalid certificate authority file '%s' or path '%s' specified for RTP instance '%p'\n",
1420                                 S_OR(dtls_cfg->cafile, ""), S_OR(dtls_cfg->capath, ""), instance);
1421                         return -1;
1422                 }
1423         }
1424
1425         rtp->rekey = dtls_cfg->rekey;
1426         rtp->suite = dtls_cfg->suite;
1427
1428         res = dtls_details_initialize(&rtp->dtls, rtp->ssl_ctx, dtls_cfg->default_setup);
1429         if (!res) {
1430                 dtls_setup_rtcp(instance);
1431         }
1432
1433         return res;
1434 }
1435
1436 static int ast_rtp_dtls_active(struct ast_rtp_instance *instance)
1437 {
1438         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1439
1440         return !rtp->ssl_ctx ? 0 : 1;
1441 }
1442
1443 static void ast_rtp_dtls_stop(struct ast_rtp_instance *instance)
1444 {
1445         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1446
1447         dtls_srtp_stop_timeout_timer(instance, rtp, 0);
1448
1449         if (rtp->ssl_ctx) {
1450                 SSL_CTX_free(rtp->ssl_ctx);
1451                 rtp->ssl_ctx = NULL;
1452         }
1453
1454         if (rtp->dtls.ssl) {
1455                 SSL_free(rtp->dtls.ssl);
1456                 rtp->dtls.ssl = NULL;
1457                 ast_mutex_destroy(&rtp->dtls.lock);
1458         }
1459
1460         if (rtp->rtcp) {
1461                 dtls_srtp_stop_timeout_timer(instance, rtp, 1);
1462
1463                 if (rtp->rtcp->dtls.ssl) {
1464                         SSL_free(rtp->rtcp->dtls.ssl);
1465                         rtp->rtcp->dtls.ssl = NULL;
1466                         ast_mutex_destroy(&rtp->rtcp->dtls.lock);
1467                 }
1468         }
1469 }
1470
1471 static void ast_rtp_dtls_reset(struct ast_rtp_instance *instance)
1472 {
1473         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1474
1475         if (SSL_is_init_finished(rtp->dtls.ssl)) {
1476                 SSL_shutdown(rtp->dtls.ssl);
1477                 rtp->dtls.connection = AST_RTP_DTLS_CONNECTION_NEW;
1478         }
1479
1480         if (rtp->rtcp && SSL_is_init_finished(rtp->rtcp->dtls.ssl)) {
1481                 SSL_shutdown(rtp->rtcp->dtls.ssl);
1482                 rtp->rtcp->dtls.connection = AST_RTP_DTLS_CONNECTION_NEW;
1483         }
1484 }
1485
1486 static enum ast_rtp_dtls_connection ast_rtp_dtls_get_connection(struct ast_rtp_instance *instance)
1487 {
1488         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1489
1490         return rtp->dtls.connection;
1491 }
1492
1493 static enum ast_rtp_dtls_setup ast_rtp_dtls_get_setup(struct ast_rtp_instance *instance)
1494 {
1495         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1496
1497         return rtp->dtls.dtls_setup;
1498 }
1499
1500 static void dtls_set_setup(enum ast_rtp_dtls_setup *dtls_setup, enum ast_rtp_dtls_setup setup, SSL *ssl)
1501 {
1502         enum ast_rtp_dtls_setup old = *dtls_setup;
1503
1504         switch (setup) {
1505         case AST_RTP_DTLS_SETUP_ACTIVE:
1506                 *dtls_setup = AST_RTP_DTLS_SETUP_PASSIVE;
1507                 break;
1508         case AST_RTP_DTLS_SETUP_PASSIVE:
1509                 *dtls_setup = AST_RTP_DTLS_SETUP_ACTIVE;
1510                 break;
1511         case AST_RTP_DTLS_SETUP_ACTPASS:
1512                 /* We can't respond to an actpass setup with actpass ourselves... so respond with active, as we can initiate connections */
1513                 if (*dtls_setup == AST_RTP_DTLS_SETUP_ACTPASS) {
1514                         *dtls_setup = AST_RTP_DTLS_SETUP_ACTIVE;
1515                 }
1516                 break;
1517         case AST_RTP_DTLS_SETUP_HOLDCONN:
1518                 *dtls_setup = AST_RTP_DTLS_SETUP_HOLDCONN;
1519                 break;
1520         default:
1521                 /* This should never occur... if it does exit early as we don't know what state things are in */
1522                 return;
1523         }
1524
1525         /* If the setup state did not change we go on as if nothing happened */
1526         if (old == *dtls_setup) {
1527                 return;
1528         }
1529
1530         /* If they don't want us to establish a connection wait until later */
1531         if (*dtls_setup == AST_RTP_DTLS_SETUP_HOLDCONN) {
1532                 return;
1533         }
1534
1535         if (*dtls_setup == AST_RTP_DTLS_SETUP_ACTIVE) {
1536                 SSL_set_connect_state(ssl);
1537         } else if (*dtls_setup == AST_RTP_DTLS_SETUP_PASSIVE) {
1538                 SSL_set_accept_state(ssl);
1539         } else {
1540                 return;
1541         }
1542 }
1543
1544 static void ast_rtp_dtls_set_setup(struct ast_rtp_instance *instance, enum ast_rtp_dtls_setup setup)
1545 {
1546         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1547
1548         if (rtp->dtls.ssl) {
1549                 dtls_set_setup(&rtp->dtls.dtls_setup, setup, rtp->dtls.ssl);
1550         }
1551
1552         if (rtp->rtcp && rtp->rtcp->dtls.ssl) {
1553                 dtls_set_setup(&rtp->rtcp->dtls.dtls_setup, setup, rtp->rtcp->dtls.ssl);
1554         }
1555 }
1556
1557 static void ast_rtp_dtls_set_fingerprint(struct ast_rtp_instance *instance, enum ast_rtp_dtls_hash hash, const char *fingerprint)
1558 {
1559         char *tmp = ast_strdupa(fingerprint), *value;
1560         int pos = 0;
1561         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1562
1563         if (hash != AST_RTP_DTLS_HASH_SHA1 && hash != AST_RTP_DTLS_HASH_SHA256) {
1564                 return;
1565         }
1566
1567         rtp->remote_hash = hash;
1568
1569         while ((value = strsep(&tmp, ":")) && (pos != (EVP_MAX_MD_SIZE - 1))) {
1570                 sscanf(value, "%02hhx", &rtp->remote_fingerprint[pos++]);
1571         }
1572 }
1573
1574 static enum ast_rtp_dtls_hash ast_rtp_dtls_get_fingerprint_hash(struct ast_rtp_instance *instance)
1575 {
1576         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1577
1578         return rtp->local_hash;
1579 }
1580
1581 static const char *ast_rtp_dtls_get_fingerprint(struct ast_rtp_instance *instance)
1582 {
1583         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1584
1585         return rtp->local_fingerprint;
1586 }
1587
1588 /* DTLS RTP Engine interface declaration */
1589 static struct ast_rtp_engine_dtls ast_rtp_dtls = {
1590         .set_configuration = ast_rtp_dtls_set_configuration,
1591         .active = ast_rtp_dtls_active,
1592         .stop = ast_rtp_dtls_stop,
1593         .reset = ast_rtp_dtls_reset,
1594         .get_connection = ast_rtp_dtls_get_connection,
1595         .get_setup = ast_rtp_dtls_get_setup,
1596         .set_setup = ast_rtp_dtls_set_setup,
1597         .set_fingerprint = ast_rtp_dtls_set_fingerprint,
1598         .get_fingerprint_hash = ast_rtp_dtls_get_fingerprint_hash,
1599         .get_fingerprint = ast_rtp_dtls_get_fingerprint,
1600 };
1601
1602 #endif
1603
1604 /* RTP Engine Declaration */
1605 static struct ast_rtp_engine asterisk_rtp_engine = {
1606         .name = "asterisk",
1607         .new = ast_rtp_new,
1608         .destroy = ast_rtp_destroy,
1609         .dtmf_begin = ast_rtp_dtmf_begin,
1610         .dtmf_end = ast_rtp_dtmf_end,
1611         .dtmf_end_with_duration = ast_rtp_dtmf_end_with_duration,
1612         .dtmf_mode_set = ast_rtp_dtmf_mode_set,
1613         .dtmf_mode_get = ast_rtp_dtmf_mode_get,
1614         .update_source = ast_rtp_update_source,
1615         .change_source = ast_rtp_change_source,
1616         .write = ast_rtp_write,
1617         .read = ast_rtp_read,
1618         .prop_set = ast_rtp_prop_set,
1619         .fd = ast_rtp_fd,
1620         .remote_address_set = ast_rtp_remote_address_set,
1621         .red_init = rtp_red_init,
1622         .red_buffer = rtp_red_buffer,
1623         .local_bridge = ast_rtp_local_bridge,
1624         .get_stat = ast_rtp_get_stat,
1625         .dtmf_compatible = ast_rtp_dtmf_compatible,
1626         .stun_request = ast_rtp_stun_request,
1627         .stop = ast_rtp_stop,
1628         .qos = ast_rtp_qos_set,
1629         .sendcng = ast_rtp_sendcng,
1630 #ifdef HAVE_PJPROJECT
1631         .ice = &ast_rtp_ice,
1632 #endif
1633 #ifdef HAVE_OPENSSL_SRTP
1634         .dtls = &ast_rtp_dtls,
1635         .activate = ast_rtp_activate,
1636 #endif
1637 };
1638
1639 #ifdef HAVE_OPENSSL_SRTP
1640 static void dtls_perform_handshake(struct ast_rtp_instance *instance, struct dtls_details *dtls, int rtcp)
1641 {
1642         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1643
1644         /* If we are not acting as a client connecting to the remote side then
1645          * don't start the handshake as it will accomplish nothing and would conflict
1646          * with the handshake we receive from the remote side.
1647          */
1648         if (!dtls->ssl || (dtls->dtls_setup != AST_RTP_DTLS_SETUP_ACTIVE)) {
1649                 return;
1650         }
1651
1652         SSL_do_handshake(dtls->ssl);
1653
1654         /* Since the handshake is started in a thread outside of the channel thread it's possible
1655          * for the response to be handled in the channel thread before we start the timeout timer.
1656          * To ensure this doesn't actually happen we hold the DTLS lock. The channel thread will
1657          * block until we're done at which point the timeout timer will be immediately stopped.
1658          */
1659         ast_mutex_lock(&dtls->lock);
1660         dtls_srtp_check_pending(instance, rtp, rtcp);
1661         dtls_srtp_start_timeout_timer(instance, rtp, rtcp);
1662         ast_mutex_unlock(&dtls->lock);
1663 }
1664 #endif
1665
1666 #ifdef HAVE_PJPROJECT
1667 static void rtp_learning_seq_init(struct rtp_learning_info *info, uint16_t seq);
1668
1669 static void ast_rtp_on_ice_complete(pj_ice_sess *ice, pj_status_t status)
1670 {
1671         struct ast_rtp_instance *instance = ice->user_data;
1672         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1673
1674         if (status == PJ_SUCCESS) {
1675                 struct ast_sockaddr remote_address;
1676
1677                 /* Symmetric RTP must be disabled for the remote address to not get overwritten */
1678                 ast_rtp_instance_set_prop(instance, AST_RTP_PROPERTY_NAT, 0);
1679
1680                 update_address_with_ice_candidate(rtp, AST_RTP_ICE_COMPONENT_RTP, &remote_address);
1681                 ast_rtp_instance_set_remote_address(instance, &remote_address);
1682
1683                 if (rtp->rtcp) {
1684                         update_address_with_ice_candidate(rtp, AST_RTP_ICE_COMPONENT_RTCP, &rtp->rtcp->them);
1685                 }
1686         }
1687  
1688 #ifdef HAVE_OPENSSL_SRTP
1689         dtls_perform_handshake(instance, &rtp->dtls, 0);
1690
1691         if (rtp->rtcp) {
1692                 dtls_perform_handshake(instance, &rtp->rtcp->dtls, 1);
1693         }
1694 #endif
1695
1696         if (!strictrtp) {
1697                 return;
1698         }
1699
1700         rtp->strict_rtp_state = STRICT_RTP_LEARN;
1701         rtp_learning_seq_init(&rtp->rtp_source_learn, (uint16_t)rtp->seqno);
1702 }
1703
1704 static void ast_rtp_on_ice_rx_data(pj_ice_sess *ice, unsigned comp_id, unsigned transport_id, void *pkt, pj_size_t size, const pj_sockaddr_t *src_addr, unsigned src_addr_len)
1705 {
1706         struct ast_rtp_instance *instance = ice->user_data;
1707         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1708
1709         /* Instead of handling the packet here (which really doesn't work with our architecture) we set a bit to indicate that it should be handled after pj_ice_sess_on_rx_pkt
1710          * returns */
1711         if (transport_id == TRANSPORT_SOCKET_RTP || transport_id == TRANSPORT_SOCKET_RTCP) {
1712                 rtp->passthrough = 1;
1713         } else if (transport_id == TRANSPORT_TURN_RTP) {
1714                 rtp->rtp_passthrough = 1;
1715         } else if (transport_id == TRANSPORT_TURN_RTCP) {
1716                 rtp->rtcp_passthrough = 1;
1717         }
1718 }
1719
1720 static pj_status_t ast_rtp_on_ice_tx_pkt(pj_ice_sess *ice, unsigned comp_id, unsigned transport_id, const void *pkt, pj_size_t size, const pj_sockaddr_t *dst_addr, unsigned dst_addr_len)
1721 {
1722         struct ast_rtp_instance *instance = ice->user_data;
1723         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1724         pj_status_t status = PJ_EINVALIDOP;
1725         pj_ssize_t _size = (pj_ssize_t)size;
1726
1727         if (transport_id == TRANSPORT_SOCKET_RTP) {
1728                 /* Traffic is destined to go right out the RTP socket we already have */
1729                 status = pj_sock_sendto(rtp->s, pkt, &_size, 0, dst_addr, dst_addr_len);
1730                 /* sendto on a connectionless socket should send all the data, or none at all */
1731                 ast_assert(_size == size || status != PJ_SUCCESS);
1732         } else if (transport_id == TRANSPORT_SOCKET_RTCP) {
1733                 /* Traffic is destined to go right out the RTCP socket we already have */
1734                 if (rtp->rtcp) {
1735                         status = pj_sock_sendto(rtp->rtcp->s, pkt, &_size, 0, dst_addr, dst_addr_len);
1736                         /* sendto on a connectionless socket should send all the data, or none at all */
1737                         ast_assert(_size == size || status != PJ_SUCCESS);
1738                 } else {
1739                         status = PJ_SUCCESS;
1740                 }
1741         } else if (transport_id == TRANSPORT_TURN_RTP) {
1742                 /* Traffic is going through the RTP TURN relay */
1743                 if (rtp->turn_rtp) {
1744                         status = pj_turn_sock_sendto(rtp->turn_rtp, pkt, size, dst_addr, dst_addr_len);
1745                 }
1746         } else if (transport_id == TRANSPORT_TURN_RTCP) {
1747                 /* Traffic is going through the RTCP TURN relay */
1748                 if (rtp->turn_rtcp) {
1749                         status = pj_turn_sock_sendto(rtp->turn_rtcp, pkt, size, dst_addr, dst_addr_len);
1750                 }
1751         }
1752
1753         return status;
1754 }
1755
1756 /* ICE Session interface declaration */
1757 static pj_ice_sess_cb ast_rtp_ice_sess_cb = {
1758         .on_ice_complete = ast_rtp_on_ice_complete,
1759         .on_rx_data = ast_rtp_on_ice_rx_data,
1760         .on_tx_pkt = ast_rtp_on_ice_tx_pkt,
1761 };
1762
1763 /*! \brief Worker thread for timerheap */
1764 static int timer_worker_thread(void *data)
1765 {
1766         pj_ioqueue_t *ioqueue;
1767
1768         if (pj_ioqueue_create(pool, 1, &ioqueue) != PJ_SUCCESS) {
1769                 return -1;
1770         }
1771
1772         while (!timer_terminate) {
1773                 const pj_time_val delay = {0, 10};
1774
1775                 pj_timer_heap_poll(timer_heap, NULL);
1776                 pj_ioqueue_poll(ioqueue, &delay);
1777         }
1778
1779         return 0;
1780 }
1781 #endif
1782
1783 static inline int rtp_debug_test_addr(struct ast_sockaddr *addr)
1784 {
1785         if (!rtpdebug) {
1786                 return 0;
1787         }
1788         if (!ast_sockaddr_isnull(&rtpdebugaddr)) {
1789                 if (rtpdebugport) {
1790                         return (ast_sockaddr_cmp(&rtpdebugaddr, addr) == 0); /* look for RTP packets from IP+Port */
1791                 } else {
1792                         return (ast_sockaddr_cmp_addr(&rtpdebugaddr, addr) == 0); /* only look for RTP packets from IP */
1793                 }
1794         }
1795
1796         return 1;
1797 }
1798
1799 static inline int rtcp_debug_test_addr(struct ast_sockaddr *addr)
1800 {
1801         if (!rtcpdebug) {
1802                 return 0;
1803         }
1804         if (!ast_sockaddr_isnull(&rtcpdebugaddr)) {
1805                 if (rtcpdebugport) {
1806                         return (ast_sockaddr_cmp(&rtcpdebugaddr, addr) == 0); /* look for RTCP packets from IP+Port */
1807                 } else {
1808                         return (ast_sockaddr_cmp_addr(&rtcpdebugaddr, addr) == 0); /* only look for RTCP packets from IP */
1809                 }
1810         }
1811
1812         return 1;
1813 }
1814
1815 #ifdef HAVE_OPENSSL_SRTP
1816 static int dtls_srtp_handle_timeout(struct ast_rtp_instance *instance, int rtcp)
1817 {
1818         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1819         struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->rtcp->dtls;
1820         struct timeval dtls_timeout;
1821
1822         DTLSv1_handle_timeout(dtls->ssl);
1823         dtls_srtp_check_pending(instance, rtp, rtcp);
1824
1825         /* If a timeout can't be retrieved then this recurring scheduled item must stop */
1826         if (!DTLSv1_get_timeout(dtls->ssl, &dtls_timeout)) {
1827                 dtls->timeout_timer = -1;
1828                 return 0;
1829         }
1830
1831         return dtls_timeout.tv_sec * 1000 + dtls_timeout.tv_usec / 1000;
1832 }
1833
1834 static int dtls_srtp_handle_rtp_timeout(const void *data)
1835 {
1836         struct ast_rtp_instance *instance = (struct ast_rtp_instance *)data;
1837         int reschedule;
1838
1839         reschedule = dtls_srtp_handle_timeout(instance, 0);
1840
1841         if (!reschedule) {
1842                 ao2_ref(instance, -1);
1843         }
1844
1845         return reschedule;
1846 }
1847
1848 static int dtls_srtp_handle_rtcp_timeout(const void *data)
1849 {
1850         struct ast_rtp_instance *instance = (struct ast_rtp_instance *)data;
1851         int reschedule;
1852
1853         reschedule = dtls_srtp_handle_timeout(instance, 1);
1854
1855         if (!reschedule) {
1856                 ao2_ref(instance, -1);
1857         }
1858
1859         return reschedule;
1860 }
1861
1862 static void dtls_srtp_start_timeout_timer(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp)
1863 {
1864         struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->rtcp->dtls;
1865         struct timeval dtls_timeout;
1866
1867         if (DTLSv1_get_timeout(dtls->ssl, &dtls_timeout)) {
1868                 int timeout = dtls_timeout.tv_sec * 1000 + dtls_timeout.tv_usec / 1000;
1869
1870                 ast_assert(dtls->timeout_timer == -1);
1871
1872                 ao2_ref(instance, +1);
1873                 if ((dtls->timeout_timer = ast_sched_add(rtp->sched, timeout,
1874                         !rtcp ? dtls_srtp_handle_rtp_timeout : dtls_srtp_handle_rtcp_timeout, instance)) < 0) {
1875                         ao2_ref(instance, -1);
1876                         ast_log(LOG_WARNING, "Scheduling '%s' DTLS retransmission for RTP instance [%p] failed.\n",
1877                                 !rtcp ? "RTP" : "RTCP", instance);
1878                 }
1879         }
1880 }
1881
1882 static void dtls_srtp_stop_timeout_timer(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp)
1883 {
1884         struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->rtcp->dtls;
1885
1886         AST_SCHED_DEL_UNREF(rtp->sched, dtls->timeout_timer, ao2_ref(instance, -1));
1887 }
1888
1889 static void dtls_srtp_check_pending(struct ast_rtp_instance *instance, struct ast_rtp *rtp, int rtcp)
1890 {
1891         struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->rtcp->dtls;
1892         size_t pending;
1893
1894         if (!dtls->ssl || !dtls->write_bio) {
1895                 return;
1896         }
1897
1898         pending = BIO_ctrl_pending(dtls->write_bio);
1899
1900         if (pending > 0) {
1901                 char outgoing[pending];
1902                 size_t out;
1903                 struct ast_sockaddr remote_address = { {0, } };
1904                 int ice;
1905
1906                 if (!rtcp) {
1907                         ast_rtp_instance_get_remote_address(instance, &remote_address);
1908                 } else {
1909                         ast_sockaddr_copy(&remote_address, &rtp->rtcp->them);
1910                 }
1911
1912                 /* If we do not yet know an address to send this to defer it until we do */
1913                 if (ast_sockaddr_isnull(&remote_address)) {
1914                         return;
1915                 }
1916
1917                 out = BIO_read(dtls->write_bio, outgoing, sizeof(outgoing));
1918                 __rtp_sendto(instance, outgoing, out, 0, &remote_address, rtcp, &ice, 0);
1919         }
1920 }
1921
1922 static int dtls_srtp_renegotiate(const void *data)
1923 {
1924         struct ast_rtp_instance *instance = (struct ast_rtp_instance *)data;
1925         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1926
1927         SSL_renegotiate(rtp->dtls.ssl);
1928         SSL_do_handshake(rtp->dtls.ssl);
1929         dtls_srtp_check_pending(instance, rtp, 0);
1930
1931         if (rtp->rtcp && rtp->rtcp->dtls.ssl) {
1932                 SSL_renegotiate(rtp->rtcp->dtls.ssl);
1933                 SSL_do_handshake(rtp->rtcp->dtls.ssl);
1934                 dtls_srtp_check_pending(instance, rtp, 1);
1935         }
1936
1937         rtp->rekeyid = -1;
1938         ao2_ref(instance, -1);
1939
1940         return 0;
1941 }
1942
1943 static int dtls_srtp_setup(struct ast_rtp *rtp, struct ast_srtp *srtp, struct ast_rtp_instance *instance)
1944 {
1945         unsigned char material[SRTP_MASTER_LEN * 2];
1946         unsigned char *local_key, *local_salt, *remote_key, *remote_salt;
1947         struct ast_srtp_policy *local_policy, *remote_policy = NULL;
1948         struct ast_rtp_instance_stats stats = { 0, };
1949         int res = -1;
1950
1951         /* If a fingerprint is present in the SDP make sure that the peer certificate matches it */
1952         if (rtp->dtls_verify & AST_RTP_DTLS_VERIFY_FINGERPRINT) {
1953                 X509 *certificate;
1954
1955                 if (!(certificate = SSL_get_peer_certificate(rtp->dtls.ssl))) {
1956                         ast_log(LOG_WARNING, "No certificate was provided by the peer on RTP instance '%p'\n", instance);
1957                         return -1;
1958                 }
1959
1960                 /* If a fingerprint is present in the SDP make sure that the peer certificate matches it */
1961                 if (rtp->remote_fingerprint[0]) {
1962                         const EVP_MD *type;
1963                         unsigned char fingerprint[EVP_MAX_MD_SIZE];
1964                         unsigned int size;
1965
1966                         if (rtp->remote_hash == AST_RTP_DTLS_HASH_SHA1) {
1967                                 type = EVP_sha1();
1968                         } else if (rtp->remote_hash == AST_RTP_DTLS_HASH_SHA256) {
1969                                 type = EVP_sha256();
1970                         } else {
1971                                 ast_log(LOG_WARNING, "Unsupported fingerprint hash type on RTP instance '%p'\n", instance);
1972                                 return -1;
1973                         }
1974
1975                         if (!X509_digest(certificate, type, fingerprint, &size) ||
1976                             !size ||
1977                             memcmp(fingerprint, rtp->remote_fingerprint, size)) {
1978                                 X509_free(certificate);
1979                                 ast_log(LOG_WARNING, "Fingerprint provided by remote party does not match that of peer certificate on RTP instance '%p'\n",
1980                                         instance);
1981                                 return -1;
1982                         }
1983                 }
1984
1985                 X509_free(certificate);
1986         }
1987
1988         /* Ensure that certificate verification was successful */
1989         if ((rtp->dtls_verify & AST_RTP_DTLS_VERIFY_CERTIFICATE) && SSL_get_verify_result(rtp->dtls.ssl) != X509_V_OK) {
1990                 ast_log(LOG_WARNING, "Peer certificate on RTP instance '%p' failed verification test\n",
1991                         instance);
1992                 return -1;
1993         }
1994
1995         /* Produce key information and set up SRTP */
1996         if (!SSL_export_keying_material(rtp->dtls.ssl, material, SRTP_MASTER_LEN * 2, "EXTRACTOR-dtls_srtp", 19, NULL, 0, 0)) {
1997                 ast_log(LOG_WARNING, "Unable to extract SRTP keying material from DTLS-SRTP negotiation on RTP instance '%p'\n",
1998                         instance);
1999                 return -1;
2000         }
2001
2002         /* Whether we are acting as a server or client determines where the keys/salts are */
2003         if (rtp->dtls.dtls_setup == AST_RTP_DTLS_SETUP_ACTIVE) {
2004                 local_key = material;
2005                 remote_key = local_key + SRTP_MASTER_KEY_LEN;
2006                 local_salt = remote_key + SRTP_MASTER_KEY_LEN;
2007                 remote_salt = local_salt + SRTP_MASTER_SALT_LEN;
2008         } else {
2009                 remote_key = material;
2010                 local_key = remote_key + SRTP_MASTER_KEY_LEN;
2011                 remote_salt = local_key + SRTP_MASTER_KEY_LEN;
2012                 local_salt = remote_salt + SRTP_MASTER_SALT_LEN;
2013         }
2014
2015         if (!(local_policy = res_srtp_policy->alloc())) {
2016                 return -1;
2017         }
2018
2019         if (res_srtp_policy->set_master_key(local_policy, local_key, SRTP_MASTER_KEY_LEN, local_salt, SRTP_MASTER_SALT_LEN) < 0) {
2020                 ast_log(LOG_WARNING, "Could not set key/salt information on local policy of '%p' when setting up DTLS-SRTP\n", rtp);
2021                 goto error;
2022         }
2023
2024         if (res_srtp_policy->set_suite(local_policy, rtp->suite)) {
2025                 ast_log(LOG_WARNING, "Could not set suite to '%u' on local policy of '%p' when setting up DTLS-SRTP\n", rtp->suite, rtp);
2026                 goto error;
2027         }
2028
2029         if (ast_rtp_instance_get_stats(instance, &stats, AST_RTP_INSTANCE_STAT_LOCAL_SSRC)) {
2030                 goto error;
2031         }
2032
2033         res_srtp_policy->set_ssrc(local_policy, stats.local_ssrc, 0);
2034
2035         if (!(remote_policy = res_srtp_policy->alloc())) {
2036                 goto error;
2037         }
2038
2039         if (res_srtp_policy->set_master_key(remote_policy, remote_key, SRTP_MASTER_KEY_LEN, remote_salt, SRTP_MASTER_SALT_LEN) < 0) {
2040                 ast_log(LOG_WARNING, "Could not set key/salt information on remote policy of '%p' when setting up DTLS-SRTP\n", rtp);
2041                 goto error;
2042         }
2043
2044         if (res_srtp_policy->set_suite(remote_policy, rtp->suite)) {
2045                 ast_log(LOG_WARNING, "Could not set suite to '%u' on remote policy of '%p' when setting up DTLS-SRTP\n", rtp->suite, rtp);
2046                 goto error;
2047         }
2048
2049         res_srtp_policy->set_ssrc(remote_policy, 0, 1);
2050
2051         if (ast_rtp_instance_add_srtp_policy(instance, remote_policy, local_policy)) {
2052                 ast_log(LOG_WARNING, "Could not set policies when setting up DTLS-SRTP on '%p'\n", rtp);
2053                 goto error;
2054         }
2055
2056         if (rtp->rekey) {
2057                 ao2_ref(instance, +1);
2058                 if ((rtp->rekeyid = ast_sched_add(rtp->sched, rtp->rekey * 1000, dtls_srtp_renegotiate, instance)) < 0) {
2059                         ao2_ref(instance, -1);
2060                         goto error;
2061                 }
2062         }
2063
2064         res = 0;
2065
2066 error:
2067         /* policy->destroy() called even on success to release local reference to these resources */
2068         res_srtp_policy->destroy(local_policy);
2069
2070         if (remote_policy) {
2071                 res_srtp_policy->destroy(remote_policy);
2072         }
2073
2074         return res;
2075 }
2076 #endif
2077
2078 static int __rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp)
2079 {
2080         int len;
2081         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2082         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
2083         char *in = buf;
2084 #ifdef HAVE_PJPROJECT
2085         struct ast_sockaddr *loop = rtcp ? &rtp->rtcp_loop : &rtp->rtp_loop;
2086 #endif
2087
2088         if ((len = ast_recvfrom(rtcp ? rtp->rtcp->s : rtp->s, buf, size, flags, sa)) < 0) {
2089            return len;
2090         }
2091
2092 #ifdef HAVE_OPENSSL_SRTP
2093         /* If this is an SSL packet pass it to OpenSSL for processing. RFC section for first byte value:
2094          * https://tools.ietf.org/html/rfc5764#section-5.1.2 */
2095         if ((*in >= 20) && (*in <= 63)) {
2096                 struct dtls_details *dtls = !rtcp ? &rtp->dtls : &rtp->rtcp->dtls;
2097                 int res = 0;
2098
2099                 /* If no SSL session actually exists terminate things */
2100                 if (!dtls->ssl) {
2101                         ast_log(LOG_ERROR, "Received SSL traffic on RTP instance '%p' without an SSL session\n",
2102                                 instance);
2103                         return -1;
2104                 }
2105
2106                 /* This mutex is locked so that this thread blocks until the dtls_perform_handshake function
2107                  * completes.
2108                  */
2109                 ast_mutex_lock(&dtls->lock);
2110                 ast_mutex_unlock(&dtls->lock);
2111
2112                 /* Before we feed data into OpenSSL ensure that the timeout timer is either stopped or completed */
2113                 dtls_srtp_stop_timeout_timer(instance, rtp, rtcp);
2114
2115                 /* If we don't yet know if we are active or passive and we receive a packet... we are obviously passive */
2116                 if (dtls->dtls_setup == AST_RTP_DTLS_SETUP_ACTPASS) {
2117                         dtls->dtls_setup = AST_RTP_DTLS_SETUP_PASSIVE;
2118                         SSL_set_accept_state(dtls->ssl);
2119                 }
2120
2121                 dtls_srtp_check_pending(instance, rtp, rtcp);
2122
2123                 BIO_write(dtls->read_bio, buf, len);
2124
2125                 len = SSL_read(dtls->ssl, buf, len);
2126
2127                 if ((len < 0) && (SSL_get_error(dtls->ssl, len) == SSL_ERROR_SSL)) {
2128                         unsigned long error = ERR_get_error();
2129                         ast_log(LOG_ERROR, "DTLS failure occurred on RTP instance '%p' due to reason '%s', terminating\n",
2130                                 instance, ERR_reason_error_string(error));
2131                         return -1;
2132                 }
2133
2134                 dtls_srtp_check_pending(instance, rtp, rtcp);
2135
2136                 if (SSL_is_init_finished(dtls->ssl)) {
2137                         /* Any further connections will be existing since this is now established */
2138                         dtls->connection = AST_RTP_DTLS_CONNECTION_EXISTING;
2139                         if (!rtcp) {
2140                                 /* Use the keying material to set up key/salt information */
2141                                 res = dtls_srtp_setup(rtp, srtp, instance);
2142                         }
2143                 } else {
2144                         /* Since we've sent additional traffic start the timeout timer for retransmission */
2145                         dtls_srtp_start_timeout_timer(instance, rtp, rtcp);
2146                 }
2147
2148                 return res;
2149         }
2150 #endif
2151
2152 #ifdef HAVE_PJPROJECT
2153         if (!ast_sockaddr_isnull(loop) && !ast_sockaddr_cmp(loop, sa)) {
2154                 /* ICE traffic will have been handled in the TURN callback, so skip it but update the address
2155                  * so it reflects the actual source and not the loopback
2156                  */
2157                 if (rtcp) {
2158                         ast_sockaddr_copy(sa, &rtp->rtcp->them);
2159                 } else {
2160                         ast_rtp_instance_get_remote_address(instance, sa);
2161                 }
2162         } else if (rtp->ice) {
2163                 pj_str_t combined = pj_str(ast_sockaddr_stringify(sa));
2164                 pj_sockaddr address;
2165                 pj_status_t status;
2166
2167                 pj_thread_register_check();
2168
2169                 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &combined, &address);
2170
2171                 status = pj_ice_sess_on_rx_pkt(rtp->ice, rtcp ? AST_RTP_ICE_COMPONENT_RTCP : AST_RTP_ICE_COMPONENT_RTP,
2172                         rtcp ? TRANSPORT_SOCKET_RTCP : TRANSPORT_SOCKET_RTP, buf, len, &address,
2173                         pj_sockaddr_get_len(&address));
2174                 if (status != PJ_SUCCESS) {
2175                         char buf[100];
2176
2177                         pj_strerror(status, buf, sizeof(buf));
2178                         ast_log(LOG_WARNING, "PJ ICE Rx error status code: %d '%s'.\n",
2179                                 (int)status, buf);
2180                         return -1;
2181                 }
2182                 if (!rtp->passthrough) {
2183                         return 0;
2184                 }
2185                 rtp->passthrough = 0;
2186         }
2187 #endif
2188
2189         if ((*in & 0xC0) && res_srtp && srtp && res_srtp->unprotect(srtp, buf, &len, rtcp) < 0) {
2190            return -1;
2191         }
2192
2193         return len;
2194 }
2195
2196 static int rtcp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
2197 {
2198         return __rtp_recvfrom(instance, buf, size, flags, sa, 1);
2199 }
2200
2201 static int rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
2202 {
2203         return __rtp_recvfrom(instance, buf, size, flags, sa, 0);
2204 }
2205
2206 static int __rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp, int *ice, int use_srtp)
2207 {
2208         int len = size;
2209         void *temp = buf;
2210         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2211         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
2212         int res;
2213
2214         *ice = 0;
2215
2216         if (use_srtp && res_srtp && srtp && res_srtp->protect(srtp, &temp, &len, rtcp) < 0) {
2217                 return -1;
2218         }
2219
2220 #ifdef HAVE_PJPROJECT
2221         if (rtp->ice) {
2222                 pj_thread_register_check();
2223
2224                 if (pj_ice_sess_send_data(rtp->ice, rtcp ? AST_RTP_ICE_COMPONENT_RTCP : AST_RTP_ICE_COMPONENT_RTP, temp, len) == PJ_SUCCESS) {
2225                         *ice = 1;
2226                         return len;
2227                 }
2228         }
2229 #endif
2230
2231         res = ast_sendto(rtcp ? rtp->rtcp->s : rtp->s, temp, len, flags, sa);
2232         if (res > 0) {
2233                 ast_rtp_instance_set_last_tx(instance, time(NULL));
2234         }
2235         return res;
2236 }
2237
2238 static int rtcp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
2239 {
2240         return __rtp_sendto(instance, buf, size, flags, sa, 1, ice, 1);
2241 }
2242
2243 static int rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
2244 {
2245         return __rtp_sendto(instance, buf, size, flags, sa, 0, ice, 1);
2246 }
2247
2248 static int rtp_get_rate(struct ast_format *format)
2249 {
2250         /* For those wondering: due to a fluke in RFC publication, G.722 is advertised
2251          * as having a sample rate of 8kHz, while implementations must know that its
2252          * real rate is 16kHz. Seriously.
2253          */
2254         return (ast_format_cmp(format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) ? 8000 : (int)ast_format_get_sample_rate(format);
2255 }
2256
2257 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
2258 {
2259         unsigned int interval;
2260         /*! \todo XXX Do a more reasonable calculation on this one
2261          * Look in RFC 3550 Section A.7 for an example*/
2262         interval = rtcpinterval;
2263         return interval;
2264 }
2265
2266 /*! \brief Calculate normal deviation */
2267 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
2268 {
2269         normdev = normdev * sample_count + sample;
2270         sample_count++;
2271
2272         return normdev / sample_count;
2273 }
2274
2275 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
2276 {
2277 /*
2278                 for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
2279                 return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
2280                 we can compute the sigma^2 and that way we would have to do the sqrt only 1 time at the end and would save another pow 2 compute
2281                 optimized formula
2282 */
2283 #define SQUARE(x) ((x) * (x))
2284
2285         stddev = sample_count * stddev;
2286         sample_count++;
2287
2288         return stddev +
2289                 ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) +
2290                 ( SQUARE(sample - normdev_curent) / sample_count );
2291
2292 #undef SQUARE
2293 }
2294
2295 static int create_new_socket(const char *type, int af)
2296 {
2297         int sock = socket(af, SOCK_DGRAM, 0);
2298
2299         if (sock < 0) {
2300                 if (!type) {
2301                         type = "RTP/RTCP";
2302                 }
2303                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
2304         } else {
2305                 long flags = fcntl(sock, F_GETFL);
2306                 fcntl(sock, F_SETFL, flags | O_NONBLOCK);
2307 #ifdef SO_NO_CHECK
2308                 if (nochecksums) {
2309                         setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2310                 }
2311 #endif
2312         }
2313
2314         return sock;
2315 }
2316
2317 /*!
2318  * \internal
2319  * \brief Initializes sequence values and probation for learning mode.
2320  * \note This is an adaptation of pjmedia's pjmedia_rtp_seq_init function.
2321  *
2322  * \param info The learning information to track
2323  * \param seq sequence number read from the rtp header to initialize the information with
2324  */
2325 static void rtp_learning_seq_init(struct rtp_learning_info *info, uint16_t seq)
2326 {
2327         info->max_seq = seq - 1;
2328         info->packets = learning_min_sequential;
2329 }
2330
2331 /*!
2332  * \internal
2333  * \brief Updates sequence information for learning mode and determines if probation/learning mode should remain in effect.
2334  * \note This function was adapted from pjmedia's pjmedia_rtp_seq_update function.
2335  *
2336  * \param info Structure tracking the learning progress of some address
2337  * \param seq sequence number read from the rtp header
2338  * \retval 0 if probation mode should exit for this address
2339  * \retval non-zero if probation mode should continue
2340  */
2341 static int rtp_learning_rtp_seq_update(struct rtp_learning_info *info, uint16_t seq)
2342 {
2343         if (seq == info->max_seq + 1) {
2344                 /* packet is in sequence */
2345                 info->packets--;
2346         } else {
2347                 /* Sequence discontinuity; reset */
2348                 info->packets = learning_min_sequential - 1;
2349         }
2350         info->max_seq = seq;
2351
2352         return (info->packets == 0);
2353 }
2354
2355 #ifdef HAVE_PJPROJECT
2356 static void rtp_add_candidates_to_ice(struct ast_rtp_instance *instance, struct ast_rtp *rtp, struct ast_sockaddr *addr, int port, int component,
2357                                       int transport)
2358 {
2359         pj_sockaddr address[16];
2360         unsigned int count = PJ_ARRAY_SIZE(address), pos = 0;
2361
2362         /* Add all the local interface IP addresses */
2363         if (ast_sockaddr_is_ipv4(addr)) {
2364                 pj_enum_ip_interface(pj_AF_INET(), &count, address);
2365         } else if (ast_sockaddr_is_any(addr)) {
2366                 pj_enum_ip_interface(pj_AF_UNSPEC(), &count, address);
2367         } else {
2368                 pj_enum_ip_interface(pj_AF_INET6(), &count, address);
2369         }
2370
2371         for (pos = 0; pos < count; pos++) {
2372                 pj_sockaddr_set_port(&address[pos], port);
2373                 ast_rtp_ice_add_cand(rtp, component, transport, PJ_ICE_CAND_TYPE_HOST, 65535, &address[pos], &address[pos], NULL,
2374                                      pj_sockaddr_get_len(&address[pos]));
2375         }
2376
2377         /* If configured to use a STUN server to get our external mapped address do so */
2378         if (stunaddr.sin_addr.s_addr && ast_sockaddr_is_ipv4(addr) && count) {
2379                 struct sockaddr_in answer;
2380
2381                 if (!ast_stun_request(component == AST_RTP_ICE_COMPONENT_RTCP ? rtp->rtcp->s : rtp->s, &stunaddr, NULL, &answer)) {
2382                         pj_sockaddr base;
2383                         pj_str_t mapped = pj_str(ast_strdupa(ast_inet_ntoa(answer.sin_addr)));
2384
2385                         /* Use the first local host candidate as the base */
2386                         pj_sockaddr_cp(&base, &address[0]);
2387
2388                         pj_sockaddr_init(pj_AF_INET(), &address[0], &mapped, ntohs(answer.sin_port));
2389
2390                         ast_rtp_ice_add_cand(rtp, component, transport, PJ_ICE_CAND_TYPE_SRFLX, 65535, &address[0], &base,
2391                                              &base, pj_sockaddr_get_len(&address[0]));
2392                 }
2393         }
2394
2395         /* If configured to use a TURN relay create a session and allocate */
2396         if (pj_strlen(&turnaddr)) {
2397                 ast_rtp_ice_turn_request(instance, component, AST_TRANSPORT_TCP, pj_strbuf(&turnaddr), turnport,
2398                         pj_strbuf(&turnusername), pj_strbuf(&turnpassword));
2399         }
2400 }
2401 #endif
2402
2403 /*!
2404  * \internal
2405  * \brief Calculates the elapsed time from issue of the first tx packet in an
2406  *        rtp session and a specified time
2407  *
2408  * \param rtp pointer to the rtp struct with the transmitted rtp packet
2409  * \param delivery time of delivery - if NULL or zero value, will be ast_tvnow()
2410  *
2411  * \return time elapsed in milliseconds
2412  */
2413 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2414 {
2415         struct timeval t;
2416         long ms;
2417
2418         if (ast_tvzero(rtp->txcore)) {
2419                 rtp->txcore = ast_tvnow();
2420                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2421         }
2422
2423         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2424         if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
2425                 ms = 0;
2426         }
2427         rtp->txcore = t;
2428
2429         return (unsigned int) ms;
2430 }
2431
2432 #ifdef HAVE_PJPROJECT
2433 /*!
2434  * \internal
2435  * \brief Creates an ICE session. Can be used to replace a destroyed ICE session.
2436  *
2437  * \param instance RTP instance for which the ICE session is being replaced
2438  * \param addr ast_sockaddr to use for adding RTP candidates to the ICE session
2439  * \param port port to use for adding RTP candidates to the ICE session
2440  * \param replace 0 when creating a new session, 1 when replacing a destroyed session
2441  *
2442  * \retval 0 on success
2443  * \retval -1 on failure
2444  */
2445 static int ice_create(struct ast_rtp_instance *instance, struct ast_sockaddr *addr,
2446         int port, int replace)
2447 {
2448         pj_stun_config stun_config;
2449         pj_str_t ufrag, passwd;
2450         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2451
2452         ao2_cleanup(rtp->ice_local_candidates);
2453         rtp->ice_local_candidates = NULL;
2454
2455         pj_thread_register_check();
2456
2457         pj_stun_config_init(&stun_config, &cachingpool.factory, 0, NULL, timer_heap);
2458
2459         ufrag = pj_str(rtp->local_ufrag);
2460         passwd = pj_str(rtp->local_passwd);
2461
2462         /* Create an ICE session for ICE negotiation */
2463         if (pj_ice_sess_create(&stun_config, NULL, PJ_ICE_SESS_ROLE_UNKNOWN, 2,
2464                         &ast_rtp_ice_sess_cb, &ufrag, &passwd, NULL, &rtp->ice) == PJ_SUCCESS) {
2465                 /* Make this available for the callbacks */
2466                 rtp->ice->user_data = instance;
2467
2468                 /* Add all of the available candidates to the ICE session */
2469                 rtp_add_candidates_to_ice(instance, rtp, addr, port, AST_RTP_ICE_COMPONENT_RTP,
2470                         TRANSPORT_SOCKET_RTP);
2471
2472                 /* Only add the RTCP candidates to ICE when replacing the session. New sessions
2473                  * handle this in a separate part of the setup phase */
2474                 if (replace && rtp->rtcp) {
2475                         rtp_add_candidates_to_ice(instance, rtp, &rtp->rtcp->us,
2476                                 ast_sockaddr_port(&rtp->rtcp->us), AST_RTP_ICE_COMPONENT_RTCP,
2477                                 TRANSPORT_SOCKET_RTCP);
2478                 }
2479
2480                 return 0;
2481         }
2482
2483         return -1;
2484
2485 }
2486 #endif
2487
2488 static int ast_rtp_new(struct ast_rtp_instance *instance,
2489                        struct ast_sched_context *sched, struct ast_sockaddr *addr,
2490                        void *data)
2491 {
2492         struct ast_rtp *rtp = NULL;
2493         int x, startplace;
2494
2495         /* Create a new RTP structure to hold all of our data */
2496         if (!(rtp = ast_calloc(1, sizeof(*rtp)))) {
2497                 return -1;
2498         }
2499
2500         /* Initialize synchronization aspects */
2501         ast_mutex_init(&rtp->lock);
2502         ast_cond_init(&rtp->cond, NULL);
2503
2504         /* Set default parameters on the newly created RTP structure */
2505         rtp->ssrc = ast_random();
2506         rtp->seqno = ast_random() & 0xffff;
2507         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
2508         if (strictrtp) {
2509                 rtp_learning_seq_init(&rtp->rtp_source_learn, (uint16_t)rtp->seqno);
2510                 rtp_learning_seq_init(&rtp->alt_source_learn, (uint16_t)rtp->seqno);
2511         }
2512
2513         /* Create a new socket for us to listen on and use */
2514         if ((rtp->s =
2515              create_new_socket("RTP",
2516                                ast_sockaddr_is_ipv4(addr) ? AF_INET  :
2517                                ast_sockaddr_is_ipv6(addr) ? AF_INET6 : -1)) < 0) {
2518                 ast_log(LOG_WARNING, "Failed to create a new socket for RTP instance '%p'\n", instance);
2519                 ast_free(rtp);
2520                 return -1;
2521         }
2522
2523         /* Now actually find a free RTP port to use */
2524         x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
2525         x = x & ~1;
2526         startplace = x;
2527
2528         for (;;) {
2529                 ast_sockaddr_set_port(addr, x);
2530                 /* Try to bind, this will tell us whether the port is available or not */
2531                 if (!ast_bind(rtp->s, addr)) {
2532                         ast_debug(1, "Allocated port %d for RTP instance '%p'\n", x, instance);
2533                         ast_rtp_instance_set_local_address(instance, addr);
2534                         break;
2535                 }
2536
2537                 x += 2;
2538                 if (x > rtpend) {
2539                         x = (rtpstart + 1) & ~1;
2540                 }
2541
2542                 /* See if we ran out of ports or if the bind actually failed because of something other than the address being in use */
2543                 if (x == startplace || (errno != EADDRINUSE && errno != EACCES)) {
2544                         ast_log(LOG_ERROR, "Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
2545                         close(rtp->s);
2546                         ast_free(rtp);
2547                         return -1;
2548                 }
2549         }
2550
2551 #ifdef HAVE_PJPROJECT
2552         generate_random_string(rtp->local_ufrag, sizeof(rtp->local_ufrag));
2553         generate_random_string(rtp->local_passwd, sizeof(rtp->local_passwd));
2554 #endif
2555         ast_rtp_instance_set_data(instance, rtp);
2556 #ifdef HAVE_PJPROJECT
2557         /* Create an ICE session for ICE negotiation */
2558         if (icesupport) {
2559                 ast_debug(3, "Creating ICE session %s (%d) for RTP instance '%p'\n", ast_sockaddr_stringify(addr), x, instance);
2560                 if (ice_create(instance, addr, x, 0)) {
2561                         ast_log(LOG_NOTICE, "Failed to start ICE session\n");
2562                 } else {
2563                         rtp->ice_port = x;
2564                         ast_sockaddr_copy(&rtp->ice_original_rtp_addr, addr);
2565                 }
2566         }
2567 #endif
2568
2569         /* Record any information we may need */
2570         rtp->sched = sched;
2571
2572 #ifdef HAVE_OPENSSL_SRTP
2573         rtp->rekeyid = -1;
2574         rtp->dtls.timeout_timer = -1;
2575 #endif
2576
2577         rtp->f.subclass.format = ao2_bump(ast_format_none);
2578         rtp->lastrxformat = ao2_bump(ast_format_none);
2579         rtp->lasttxformat = ao2_bump(ast_format_none);
2580
2581         return 0;
2582 }
2583
2584 static int ast_rtp_destroy(struct ast_rtp_instance *instance)
2585 {
2586         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2587 #ifdef HAVE_PJPROJECT
2588         struct timeval wait = ast_tvadd(ast_tvnow(), ast_samp2tv(TURN_STATE_WAIT_TIME, 1000));
2589         struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
2590 #endif
2591
2592 #ifdef HAVE_OPENSSL_SRTP
2593         ast_rtp_dtls_stop(instance);
2594 #endif
2595
2596         /* Destroy the smoother that was smoothing out audio if present */
2597         if (rtp->smoother) {
2598                 ast_smoother_free(rtp->smoother);
2599         }
2600
2601         /* Close our own socket so we no longer get packets */
2602         if (rtp->s > -1) {
2603                 close(rtp->s);
2604         }
2605
2606         /* Destroy RTCP if it was being used */
2607         if (rtp->rtcp) {
2608                 /*
2609                  * It is not possible for there to be an active RTCP scheduler
2610                  * entry at this point since it holds a reference to the
2611                  * RTP instance while it's active.
2612                  */
2613                 close(rtp->rtcp->s);
2614                 ast_free(rtp->rtcp);
2615         }
2616
2617         /* Destroy RED if it was being used */
2618         if (rtp->red) {
2619                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2620                 ast_free(rtp->red);
2621         }
2622
2623 #ifdef HAVE_PJPROJECT
2624         pj_thread_register_check();
2625
2626         /* Destroy the RTP TURN relay if being used */
2627         ast_mutex_lock(&rtp->lock);
2628         if (rtp->turn_rtp) {
2629                 pj_turn_sock_destroy(rtp->turn_rtp);
2630                 rtp->turn_state = PJ_TURN_STATE_NULL;
2631                 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
2632                         ast_cond_timedwait(&rtp->cond, &rtp->lock, &ts);
2633                 }
2634         }
2635
2636         /* Destroy the RTCP TURN relay if being used */
2637         if (rtp->turn_rtcp) {
2638                 pj_turn_sock_destroy(rtp->turn_rtcp);
2639                 rtp->turn_state = PJ_TURN_STATE_NULL;
2640                 while (rtp->turn_state != PJ_TURN_STATE_DESTROYING) {
2641                         ast_cond_timedwait(&rtp->cond, &rtp->lock, &ts);
2642                 }
2643         }
2644         ast_mutex_unlock(&rtp->lock);
2645
2646         if (rtp->ioqueue) {
2647                 rtp_ioqueue_thread_remove(rtp->ioqueue);
2648         }
2649
2650         /* Destroy the ICE session if being used */
2651         if (rtp->ice) {
2652                 pj_ice_sess_destroy(rtp->ice);
2653         }
2654
2655         /* Destroy any candidates */
2656         if (rtp->ice_local_candidates) {
2657                 ao2_ref(rtp->ice_local_candidates, -1);
2658         }
2659
2660         if (rtp->ice_active_remote_candidates) {
2661                 ao2_ref(rtp->ice_active_remote_candidates, -1);
2662         }
2663 #endif
2664
2665         ao2_cleanup(rtp->lasttxformat);
2666         ao2_cleanup(rtp->lastrxformat);
2667         ao2_cleanup(rtp->f.subclass.format);
2668
2669         /* Destroy synchronization items */
2670         ast_mutex_destroy(&rtp->lock);
2671         ast_cond_destroy(&rtp->cond);
2672
2673         /* Finally destroy ourselves */
2674         ast_free(rtp);
2675
2676         return 0;
2677 }
2678
2679 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
2680 {
2681         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2682         rtp->dtmfmode = dtmf_mode;
2683         return 0;
2684 }
2685
2686 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance)
2687 {
2688         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2689         return rtp->dtmfmode;
2690 }
2691
2692 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
2693 {
2694         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2695         struct ast_sockaddr remote_address = { {0,} };
2696         int hdrlen = 12, res = 0, i = 0, payload = 101;
2697         char data[256];
2698         unsigned int *rtpheader = (unsigned int*)data;
2699
2700         ast_rtp_instance_get_remote_address(instance, &remote_address);
2701
2702         /* If we have no remote address information bail out now */
2703         if (ast_sockaddr_isnull(&remote_address)) {
2704                 return -1;
2705         }
2706
2707         /* Convert given digit into what we want to transmit */
2708         if ((digit <= '9') && (digit >= '0')) {
2709                 digit -= '0';
2710         } else if (digit == '*') {
2711                 digit = 10;
2712         } else if (digit == '#') {
2713                 digit = 11;
2714         } else if ((digit >= 'A') && (digit <= 'D')) {
2715                 digit = digit - 'A' + 12;
2716         } else if ((digit >= 'a') && (digit <= 'd')) {
2717                 digit = digit - 'a' + 12;
2718         } else {
2719                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2720                 return -1;
2721         }
2722
2723         /* Grab the payload that they expect the RFC2833 packet to be received in */
2724         payload = ast_rtp_codecs_payload_code_tx(ast_rtp_instance_get_codecs(instance), 0, NULL, AST_RTP_DTMF);
2725
2726         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2727         rtp->send_duration = 160;
2728         rtp->lastts += calc_txstamp(rtp, NULL) * DTMF_SAMPLE_RATE_MS;
2729         rtp->lastdigitts = rtp->lastts + rtp->send_duration;
2730
2731         /* Create the actual packet that we will be sending */
2732         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2733         rtpheader[1] = htonl(rtp->lastdigitts);
2734         rtpheader[2] = htonl(rtp->ssrc);
2735
2736         /* Actually send the packet */
2737         for (i = 0; i < 2; i++) {
2738                 int ice;
2739
2740                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2741                 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
2742                 if (res < 0) {
2743                         ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
2744                                 ast_sockaddr_stringify(&remote_address),
2745                                 strerror(errno));
2746                 }
2747                 if (rtp_debug_test_addr(&remote_address)) {
2748                         ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
2749                                     ast_sockaddr_stringify(&remote_address),
2750                                     ice ? " (via ICE)" : "",
2751                                     payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2752                 }
2753                 rtp->seqno++;
2754                 rtp->send_duration += 160;
2755                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2756         }
2757
2758         /* Record that we are in the process of sending a digit and information needed to continue doing so */
2759         rtp->sending_digit = 1;
2760         rtp->send_digit = digit;
2761         rtp->send_payload = payload;
2762
2763         return 0;
2764 }
2765
2766 static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
2767 {
2768         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2769         struct ast_sockaddr remote_address = { {0,} };
2770         int hdrlen = 12, res = 0;
2771         char data[256];
2772         unsigned int *rtpheader = (unsigned int*)data;
2773         int ice;
2774
2775         ast_rtp_instance_get_remote_address(instance, &remote_address);
2776
2777         /* Make sure we know where the other side is so we can send them the packet */
2778         if (ast_sockaddr_isnull(&remote_address)) {
2779                 return -1;
2780         }
2781
2782         /* Actually create the packet we will be sending */
2783         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2784         rtpheader[1] = htonl(rtp->lastdigitts);
2785         rtpheader[2] = htonl(rtp->ssrc);
2786         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2787
2788         /* Boom, send it on out */
2789         res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
2790         if (res < 0) {
2791                 ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
2792                         ast_sockaddr_stringify(&remote_address),
2793                         strerror(errno));
2794         }
2795
2796         if (rtp_debug_test_addr(&remote_address)) {
2797                 ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
2798                             ast_sockaddr_stringify(&remote_address),
2799                             ice ? " (via ICE)" : "",
2800                             rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2801         }
2802
2803         /* And now we increment some values for the next time we swing by */
2804         rtp->seqno++;
2805         rtp->send_duration += 160;
2806         rtp->lastts += calc_txstamp(rtp, NULL) * DTMF_SAMPLE_RATE_MS;
2807
2808         return 0;
2809 }
2810
2811 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
2812 {
2813         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2814         struct ast_sockaddr remote_address = { {0,} };
2815         int hdrlen = 12, res = -1, i = 0;
2816         char data[256];
2817         unsigned int *rtpheader = (unsigned int*)data;
2818         unsigned int measured_samples;
2819
2820         ast_rtp_instance_get_remote_address(instance, &remote_address);
2821
2822         /* Make sure we know where the remote side is so we can send them the packet we construct */
2823         if (ast_sockaddr_isnull(&remote_address)) {
2824                 goto cleanup;
2825         }
2826
2827         /* Convert the given digit to the one we are going to send */
2828         if ((digit <= '9') && (digit >= '0')) {
2829                 digit -= '0';
2830         } else if (digit == '*') {
2831                 digit = 10;
2832         } else if (digit == '#') {
2833                 digit = 11;
2834         } else if ((digit >= 'A') && (digit <= 'D')) {
2835                 digit = digit - 'A' + 12;
2836         } else if ((digit >= 'a') && (digit <= 'd')) {
2837                 digit = digit - 'a' + 12;
2838         } else {
2839                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2840                 goto cleanup;
2841         }
2842
2843         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2844
2845         if (duration > 0 && (measured_samples = duration * rtp_get_rate(rtp->f.subclass.format) / 1000) > rtp->send_duration) {
2846                 ast_debug(2, "Adjusting final end duration from %d to %u\n", rtp->send_duration, measured_samples);
2847                 rtp->send_duration = measured_samples;
2848         }
2849
2850         /* Construct the packet we are going to send */
2851         rtpheader[1] = htonl(rtp->lastdigitts);
2852         rtpheader[2] = htonl(rtp->ssrc);
2853         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2854         rtpheader[3] |= htonl((1 << 23));
2855
2856         /* Send it 3 times, that's the magical number */
2857         for (i = 0; i < 3; i++) {
2858                 int ice;
2859
2860                 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2861
2862                 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
2863
2864                 if (res < 0) {
2865                         ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
2866                                 ast_sockaddr_stringify(&remote_address),
2867                                 strerror(errno));
2868                 }
2869
2870                 if (rtp_debug_test_addr(&remote_address)) {
2871                         ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
2872                                     ast_sockaddr_stringify(&remote_address),
2873                                     ice ? " (via ICE)" : "",
2874                                     rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2875                 }
2876
2877                 rtp->seqno++;
2878         }
2879         res = 0;
2880
2881         /* Oh and we can't forget to turn off the stuff that says we are sending DTMF */
2882         rtp->lastts += calc_txstamp(rtp, NULL) * DTMF_SAMPLE_RATE_MS;
2883 cleanup:
2884         rtp->sending_digit = 0;
2885         rtp->send_digit = 0;
2886
2887         return res;
2888 }
2889
2890 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
2891 {
2892         return ast_rtp_dtmf_end_with_duration(instance, digit, 0);
2893 }
2894
2895 static void ast_rtp_update_source(struct ast_rtp_instance *instance)
2896 {
2897         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2898
2899         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
2900         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2901         ast_debug(3, "Setting the marker bit due to a source update\n");
2902
2903         return;
2904 }
2905
2906 static void ast_rtp_change_source(struct ast_rtp_instance *instance)
2907 {
2908         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2909         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
2910         unsigned int ssrc = ast_random();
2911
2912         if (!rtp->lastts) {
2913                 ast_debug(3, "Not changing SSRC since we haven't sent any RTP yet\n");
2914                 return;
2915         }
2916
2917         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
2918         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2919
2920         ast_debug(3, "Changing ssrc from %u to %u due to a source change\n", rtp->ssrc, ssrc);
2921
2922         if (srtp) {
2923                 ast_debug(3, "Changing ssrc for SRTP from %u to %u\n", rtp->ssrc, ssrc);
2924                 res_srtp->change_source(srtp, rtp->ssrc, ssrc);
2925         }
2926
2927         rtp->ssrc = ssrc;
2928
2929         return;
2930 }
2931
2932 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
2933 {
2934         unsigned int sec, usec, frac;
2935         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
2936         usec = tv.tv_usec;
2937         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
2938         *msw = sec;
2939         *lsw = frac;
2940 }
2941
2942 static void ntp2timeval(unsigned int msw, unsigned int lsw, struct timeval *tv)
2943 {
2944         tv->tv_sec = msw - 2208988800u;
2945         tv->tv_usec = ((lsw << 6) / 3650) - (lsw >> 12) - (lsw >> 8);
2946 }
2947
2948 static void calculate_lost_packet_statistics(struct ast_rtp *rtp,
2949                 unsigned int *lost_packets,
2950                 int *fraction_lost)
2951 {
2952         unsigned int extended_seq_no;
2953         unsigned int expected_packets;
2954         unsigned int expected_interval;
2955         unsigned int received_interval;
2956         double rxlost_current;
2957         int lost_interval;
2958
2959         /* Compute statistics */
2960         extended_seq_no = rtp->cycles + rtp->lastrxseqno;
2961         expected_packets = extended_seq_no - rtp->seedrxseqno + 1;
2962         if (rtp->rxcount > expected_packets) {
2963                 expected_packets += rtp->rxcount - expected_packets;
2964         }
2965         *lost_packets = expected_packets - rtp->rxcount;
2966         expected_interval = expected_packets - rtp->rtcp->expected_prior;
2967         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2968         lost_interval = expected_interval - received_interval;
2969         if (expected_interval == 0 || lost_interval <= 0) {
2970                 *fraction_lost = 0;
2971         } else {
2972                 *fraction_lost = (lost_interval << 8) / expected_interval;
2973         }
2974
2975         /* Update RTCP statistics */
2976         rtp->rtcp->received_prior = rtp->rxcount;
2977         rtp->rtcp->expected_prior = expected_packets;
2978         if (lost_interval <= 0) {
2979                 rtp->rtcp->rxlost = 0;
2980         } else {
2981                 rtp->rtcp->rxlost = lost_interval;
2982         }
2983         if (rtp->rtcp->rxlost_count == 0) {
2984                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
2985         }
2986         if (lost_interval < rtp->rtcp->minrxlost) {
2987                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
2988         }
2989         if (lost_interval > rtp->rtcp->maxrxlost) {
2990                 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
2991         }
2992         rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost,
2993                         rtp->rtcp->rxlost,
2994                         rtp->rtcp->rxlost_count);
2995         rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost,
2996                         rtp->rtcp->rxlost,
2997                         rtp->rtcp->normdev_rxlost,
2998                         rxlost_current,
2999                         rtp->rtcp->rxlost_count);
3000         rtp->rtcp->normdev_rxlost = rxlost_current;
3001         rtp->rtcp->rxlost_count++;
3002 }
3003
3004 /*! \brief Send RTCP SR or RR report */
3005 static int ast_rtcp_write_report(struct ast_rtp_instance *instance, int sr)
3006 {
3007         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3008         RAII_VAR(struct ast_json *, message_blob, NULL, ast_json_unref);
3009         int res;
3010         int len = 0;
3011         struct timeval now;
3012         unsigned int now_lsw;
3013         unsigned int now_msw;
3014         unsigned int *rtcpheader;
3015         unsigned int lost_packets;
3016         int fraction_lost;
3017         struct timeval dlsr = { 0, };
3018         char bdata[512];
3019         int rate = rtp_get_rate(rtp->f.subclass.format);
3020         int ice;
3021         int header_offset = 0;
3022         char *str_remote_address;
3023         char *str_local_address;
3024         struct ast_sockaddr remote_address = { { 0, } };
3025         struct ast_sockaddr local_address = { { 0, } };
3026         struct ast_sockaddr real_remote_address = { { 0, } };
3027         struct ast_sockaddr real_local_address = { { 0, } };
3028         struct ast_rtp_rtcp_report_block *report_block = NULL;
3029         RAII_VAR(struct ast_rtp_rtcp_report *, rtcp_report,
3030                         ast_rtp_rtcp_report_alloc(rtp->themssrc ? 1 : 0),
3031                         ao2_cleanup);
3032
3033         if (!rtp || !rtp->rtcp) {
3034                 return 0;
3035         }
3036
3037         if (ast_sockaddr_isnull(&rtp->rtcp->them)) {  /* This'll stop rtcp for this rtp session */
3038                 /* RTCP was stopped. */
3039                 return 0;
3040         }
3041
3042         if (!rtcp_report) {
3043                 return 1;
3044         }
3045
3046         /* Compute statistics */
3047         calculate_lost_packet_statistics(rtp, &lost_packets, &fraction_lost);
3048
3049         gettimeofday(&now, NULL);
3050         rtcp_report->reception_report_count = rtp->themssrc ? 1 : 0;
3051         rtcp_report->ssrc = rtp->ssrc;
3052         rtcp_report->type = sr ? RTCP_PT_SR : RTCP_PT_RR;
3053         if (sr) {
3054                 rtcp_report->sender_information.ntp_timestamp = now;
3055                 rtcp_report->sender_information.rtp_timestamp = rtp->lastts;
3056                 rtcp_report->sender_information.packet_count = rtp->txcount;
3057                 rtcp_report->sender_information.octet_count = rtp->txoctetcount;
3058         }
3059
3060         if (rtp->themssrc) {
3061                 report_block = ast_calloc(1, sizeof(*report_block));
3062                 if (!report_block) {
3063                         return 1;
3064                 }
3065
3066                 rtcp_report->report_block[0] = report_block;
3067                 report_block->source_ssrc = rtp->themssrc;
3068                 report_block->lost_count.fraction = (fraction_lost & 0xff);
3069                 report_block->lost_count.packets = (lost_packets & 0xffffff);
3070                 report_block->highest_seq_no = (rtp->cycles | (rtp->lastrxseqno & 0xffff));
3071                 report_block->ia_jitter = (unsigned int)(rtp->rxjitter * rate);
3072                 report_block->lsr = rtp->rtcp->themrxlsr;
3073                 /* If we haven't received an SR report, DLSR should be 0 */
3074                 if (!ast_tvzero(rtp->rtcp->rxlsr)) {
3075                         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
3076                         report_block->dlsr = (((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000;
3077                 }
3078         }
3079         timeval2ntp(rtcp_report->sender_information.ntp_timestamp, &now_msw, &now_lsw);
3080         rtcpheader = (unsigned int *)bdata;
3081         rtcpheader[1] = htonl(rtcp_report->ssrc);            /* Our SSRC */
3082         len += 8;
3083         if (sr) {
3084                 header_offset = 5;
3085                 rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
3086                 rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
3087                 rtcpheader[4] = htonl(rtcp_report->sender_information.rtp_timestamp);
3088                 rtcpheader[5] = htonl(rtcp_report->sender_information.packet_count);
3089                 rtcpheader[6] = htonl(rtcp_report->sender_information.octet_count);
3090                 len += 20;
3091         }
3092         if (report_block) {
3093                 rtcpheader[2 + header_offset] = htonl(report_block->source_ssrc);     /* Their SSRC */
3094                 rtcpheader[3 + header_offset] = htonl((report_block->lost_count.fraction << 24) | report_block->lost_count.packets);
3095                 rtcpheader[4 + header_offset] = htonl(report_block->highest_seq_no);
3096                 rtcpheader[5 + header_offset] = htonl(report_block->ia_jitter);
3097                 rtcpheader[6 + header_offset] = htonl(report_block->lsr);
3098                 rtcpheader[7 + header_offset] = htonl(report_block->dlsr);
3099                 len += 24;
3100         }
3101         rtcpheader[0] = htonl((2 << 30) | (rtcp_report->reception_report_count << 24)
3102                                         | ((sr ? RTCP_PT_SR : RTCP_PT_RR) << 16) | ((len/4)-1));
3103
3104         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
3105         /* it can change mid call, and SDES can't) */
3106         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
3107         rtcpheader[(len/4)+1] = htonl(rtcp_report->ssrc);
3108         rtcpheader[(len/4)+2] = htonl(0x01 << 24);
3109         len += 12;
3110
3111         ast_sockaddr_copy(&remote_address, &rtp->rtcp->them);
3112         res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &remote_address, &ice);
3113         if (res < 0) {
3114                 ast_log(LOG_ERROR, "RTCP %s transmission error to %s, rtcp halted %s\n",
3115                         sr ? "SR" : "RR",
3116                         ast_sockaddr_stringify(&rtp->rtcp->them),
3117                         strerror(errno));
3118                 return 0;
3119         }
3120
3121         /* Update RTCP SR/RR statistics */
3122         if (sr) {
3123                 rtp->rtcp->txlsr = rtcp_report->sender_information.ntp_timestamp;
3124                 rtp->rtcp->sr_count++;
3125                 rtp->rtcp->lastsrtxcount = rtp->txcount;
3126         } else {
3127                 rtp->rtcp->rr_count++;
3128         }
3129
3130         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
3131                 ast_verbose("* Sent RTCP %s to %s%s\n", sr ? "SR" : "RR",
3132                                 ast_sockaddr_stringify(&remote_address), ice ? " (via ICE)" : "");
3133                 ast_verbose("  Our SSRC: %u\n", rtcp_report->ssrc);
3134                 if (sr) {
3135                         ast_verbose("  Sent(NTP): %u.%010u\n",
3136                                 (unsigned int)rtcp_report->sender_information.ntp_timestamp.tv_sec,
3137                                 (unsigned int)rtcp_report->sender_information.ntp_timestamp.tv_usec * 4096);
3138                         ast_verbose("  Sent(RTP): %u\n", rtcp_report->sender_information.rtp_timestamp);
3139                         ast_verbose("  Sent packets: %u\n", rtcp_report->sender_information.packet_count);
3140                         ast_verbose("  Sent octets: %u\n", rtcp_report->sender_information.octet_count);
3141                 }
3142                 if (report_block) {
3143                         ast_verbose("  Report block:\n");
3144                         ast_verbose("    Their SSRC: %u\n", report_block->source_ssrc);
3145                         ast_verbose("    Fraction lost: %d\n", report_block->lost_count.fraction);
3146                         ast_verbose("    Cumulative loss: %u\n", report_block->lost_count.packets);
3147                         ast_verbose("    Highest seq no: %u\n", report_block->highest_seq_no);
3148                         ast_verbose("    IA jitter: %.4f\n", (double)report_block->ia_jitter / rate);
3149                         ast_verbose("    Their last SR: %u\n", report_block->lsr);
3150                         ast_verbose("    DLSR: %4.4f (sec)\n\n", (double)(report_block->dlsr / 65536.0));
3151                 }
3152         }
3153
3154         ast_rtp_instance_get_local_address(instance, &local_address);
3155         if (!ast_find_ourip(&real_local_address, &local_address, 0)) {
3156                 str_local_address = ast_strdupa(ast_sockaddr_stringify(&real_local_address));
3157         } else {
3158                 str_local_address = ast_strdupa(ast_sockaddr_stringify(&local_address));
3159         }
3160
3161         if (!ast_find_ourip(&real_remote_address, &remote_address, 0)) {
3162                 str_remote_address = ast_strdupa(ast_sockaddr_stringify(&real_remote_address));
3163         } else {
3164                 str_remote_address = ast_strdupa(ast_sockaddr_stringify(&remote_address));
3165         }
3166
3167         message_blob = ast_json_pack("{s: s, s: s}",
3168                         "to", str_remote_address,
3169                         "from", str_local_address);
3170         ast_rtp_publish_rtcp_message(instance, ast_rtp_rtcp_sent_type(),
3171                         rtcp_report,
3172                         message_blob);
3173         return res;
3174 }
3175
3176 /*! \brief Write and RTCP packet to the far end
3177  * \note Decide if we are going to send an SR (with Reception Block) or RR
3178  * RR is sent if we have not sent any rtp packets in the previous interval */
3179 static int ast_rtcp_write(const void *data)
3180 {
3181         struct ast_rtp_instance *instance = (struct ast_rtp_instance *) data;
3182         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3183         int res;
3184
3185         if (!rtp || !rtp->rtcp || rtp->rtcp->schedid == -1) {
3186                 ao2_ref(instance, -1);
3187                 return 0;
3188         }
3189
3190         if (rtp->txcount > rtp->rtcp->lastsrtxcount) {
3191                 /* Send an SR */
3192                 res = ast_rtcp_write_report(instance, 1);
3193         } else {
3194                 /* Send an RR */
3195                 res = ast_rtcp_write_report(instance, 0);
3196         }
3197
3198         if (!res) {
3199                 /*
3200                  * Not being rescheduled.
3201                  */
3202                 rtp->rtcp->schedid = -1;
3203                 ao2_ref(instance, -1);
3204         }
3205
3206         return res;
3207 }
3208
3209 static int ast_rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
3210 {
3211         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3212         int pred, mark = 0;
3213         unsigned int ms = calc_txstamp(rtp, &frame->delivery);
3214         struct ast_sockaddr remote_address = { {0,} };
3215         int rate = rtp_get_rate(frame->subclass.format) / 1000;
3216
3217         if (ast_format_cmp(frame->subclass.format, ast_format_g722) == AST_FORMAT_CMP_EQUAL) {
3218                 frame->samples /= 2;
3219         }
3220
3221         if (rtp->sending_digit) {
3222                 return 0;
3223         }
3224
3225         if (frame->frametype == AST_FRAME_VOICE) {
3226                 pred = rtp->lastts + frame->samples;
3227
3228                 /* Re-calculate last TS */
3229                 rtp->lastts = rtp->lastts + ms * rate;
3230                 if (ast_tvzero(frame->delivery)) {
3231                         /* If this isn't an absolute delivery time, Check if it is close to our prediction,
3232                            and if so, go with our prediction */
3233                         if (abs((int)rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) {
3234                                 rtp->lastts = pred;
3235                         } else {
3236                                 ast_debug(3, "Difference is %d, ms is %u\n", abs((int)rtp->lastts - pred), ms);
3237                                 mark = 1;
3238                         }
3239                 }
3240         } else if (frame->frametype == AST_FRAME_VIDEO) {
3241                 mark = frame->subclass.frame_ending;
3242                 pred = rtp->lastovidtimestamp + frame->samples;
3243                 /* Re-calculate last TS */
3244                 rtp->lastts = rtp->lastts + ms * 90;
3245                 /* If it's close to our prediction, go for it */
3246                 if (ast_tvzero(frame->delivery)) {
3247                         if (abs((int)rtp->lastts - pred) < 7200) {
3248                                 rtp->lastts = pred;
3249                                 rtp->lastovidtimestamp += frame->samples;
3250                         } else {
3251                                 ast_debug(3, "Difference is %d, ms is %u (%u), pred/ts/samples %u/%d/%d\n", abs((int)rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, frame->samples);
3252                                 rtp->lastovidtimestamp = rtp->lastts;
3253                         }
3254                 }
3255         } else {
3256                 pred = rtp->lastotexttimestamp + frame->samples;
3257                 /* Re-calculate last TS */
3258                 rtp->lastts = rtp->lastts + ms;
3259                 /* If it's close to our prediction, go for it */
3260                 if (ast_tvzero(frame->delivery)) {
3261                         if (abs((int)rtp->lastts - pred) < 7200) {
3262                                 rtp->lastts = pred;
3263                                 rtp->lastotexttimestamp += frame->samples;
3264                         } else {
3265                                 ast_debug(3, "Difference is %d, ms is %u, pred/ts/samples %u/%d/%d\n", abs((int)rtp->lastts - pred), ms, rtp->lastts, pred, frame->samples);
3266                                 rtp->lastotexttimestamp = rtp->lastts;
3267                         }
3268                 }
3269         }
3270
3271         /* If we have been explicitly told to set the marker bit then do so */
3272         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
3273                 mark = 1;
3274                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
3275         }
3276
3277         /* If the timestamp for non-digt packets has moved beyond the timestamp for digits, update the digit timestamp */
3278         if (rtp->lastts > rtp->lastdigitts) {
3279                 rtp->lastdigitts = rtp->lastts;
3280         }
3281
3282         if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
3283                 rtp->lastts = frame->ts * rate;
3284         }
3285
3286         ast_rtp_instance_get_remote_address(instance, &remote_address);
3287
3288         /* If we know the remote address construct a packet and send it out */
3289         if (!ast_sockaddr_isnull(&remote_address)) {
3290                 int hdrlen = 12, res, ice;
3291                 unsigned char *rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);
3292
3293                 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
3294                 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
3295                 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
3296
3297                 if ((res = rtp_sendto(instance, (void *)rtpheader, frame->datalen + hdrlen, 0, &remote_address, &ice)) < 0) {
3298                         if (!ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT) && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
3299                                 ast_debug(1, "RTP Transmission error of packet %d to %s: %s\n",
3300                                           rtp->seqno,
3301                                           ast_sockaddr_stringify(&remote_address),
3302                                           strerror(errno));
3303                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
3304                                 /* Only give this error message once if we are not RTP debugging */
3305                                 if (rtpdebug)
3306                                         ast_debug(0, "RTP NAT: Can't write RTP to private address %s, waiting for other end to send audio...\n",
3307                                                   ast_sockaddr_stringify(&remote_address));
3308                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
3309                         }
3310                 } else {
3311                         rtp->txcount++;
3312                         rtp->txoctetcount += (res - hdrlen);
3313
3314                         if (rtp->rtcp && rtp->rtcp->schedid < 0) {
3315                                 ast_debug(1, "Starting RTCP transmission on RTP instance '%p'\n", instance);
3316                                 ao2_ref(instance, +1);
3317                                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
3318                                 if (rtp->rtcp->schedid < 0) {
3319                                         ao2_ref(instance, -1);
3320                                         ast_log(LOG_WARNING, "scheduling RTCP transmission failed.\n");
3321                                 }
3322                         }
3323                 }
3324
3325                 if (rtp_debug_test_addr(&remote_address)) {
3326                         ast_verbose("Sent RTP packet to      %s%s (type %-2.2d, seq %-6.6d, ts %-6.6u, len %-6.6d)\n",
3327                                     ast_sockaddr_stringify(&remote_address),
3328                                     ice ? " (via ICE)" : "",
3329                                     codec, rtp->seqno, rtp->lastts, res - hdrlen);
3330                 }
3331         }
3332
3333         rtp->seqno++;
3334
3335         return 0;
3336 }
3337
3338 static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
3339         unsigned char *data = red->t140red.data.ptr;
3340         int len = 0;
3341         int i;
3342
3343         /* replace most aged generation */
3344         if (red->len[0]) {
3345                 for (i = 1; i < red->num_gen+1; i++)
3346                         len += red->len[i];
3347
3348                 memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len);
3349         }
3350
3351         /* Store length of each generation and primary data length*/
3352         for (i = 0; i < red->num_gen; i++)
3353                 red->len[i] = red->len[i+1];
3354         red->len[i] = red->t140.datalen;
3355
3356         /* write each generation length in red header */
3357         len = red->hdrlen;
3358         for (i = 0; i < red->num_gen; i++) {
3359                 len += data[i*4+3] = red->len[i];
3360         }
3361
3362         /* add primary data to buffer */
3363         memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
3364         red->t140red.datalen = len + red->t140.datalen;
3365
3366         /* no primary data and no generations to send */
3367         if (len == red->hdrlen && !red->t140.datalen) {
3368                 return NULL;
3369         }
3370
3371         /* reset t.140 buffer */
3372         red->t140.datalen = 0;
3373
3374         return &red->t140red;
3375 }
3376
3377 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
3378 {
3379         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3380         struct ast_sockaddr remote_address = { {0,} };
3381         struct ast_format *format;
3382         int codec;
3383
3384         ast_rtp_instance_get_remote_address(instance, &remote_address);
3385
3386         /* If we don't actually know the remote address don't even bother doing anything */
3387         if (ast_sockaddr_isnull(&remote_address)) {
3388                 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
3389                 return 0;
3390         }
3391
3392         /* VP8: is this a request to send a RTCP FIR? */
3393         if (frame->frametype == AST_FRAME_CONTROL && frame->subclass.integer == AST_CONTROL_VIDUPDATE) {
3394                 struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3395                 unsigned int *rtcpheader;
3396                 char bdata[1024];
3397                 int len = 20;
3398                 int ice;
3399                 int res;
3400
3401                 if (!rtp || !rtp->rtcp) {
3402                         return 0;
3403                 }
3404
3405                 if (ast_sockaddr_isnull(&rtp->rtcp->them)) {
3406                         /*
3407                          * RTCP was stopped.
3408                          */
3409                         return 0;
3410                 }
3411
3412                 /* Prepare RTCP FIR (PT=206, FMT=4) */
3413                 rtp->rtcp->firseq++;
3414                 if(rtp->rtcp->firseq == 256) {
3415                         rtp->rtcp->firseq = 0;
3416                 }
3417
3418                 rtcpheader = (unsigned int *)bdata;
3419                 rtcpheader[0] = htonl((2 << 30) | (4 << 24) | (RTCP_PT_PSFB << 16) | ((len/4)-1));
3420                 rtcpheader[1] = htonl(rtp->ssrc);
3421                 rtcpheader[2] = htonl(rtp->themssrc);
3422                 rtcpheader[3] = htonl(rtp->themssrc);   /* FCI: SSRC */
3423                 rtcpheader[4] = htonl(rtp->rtcp->firseq << 24);                 /* FCI: Sequence number */
3424                 res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &rtp->rtcp->them, &ice);
3425                 if (res < 0) {
3426                         ast_log(LOG_ERROR, "RTCP FIR transmission error: %s\n", strerror(errno));
3427                 }
3428                 return 0;
3429         }
3430
3431         /* If there is no data length we can't very well send the packet */
3432         if (!frame->datalen) {
3433                 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
3434                 return 0;
3435         }
3436
3437         /* If the packet is not one our RTP stack supports bail out */
3438         if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
3439                 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
3440                 return -1;
3441         }
3442
3443         if (rtp->red) {
3444                 /* return 0; */
3445                 /* no primary data or generations to send */
3446                 if ((frame = red_t140_to_red(rtp->red)) == NULL)
3447                         return 0;
3448         }
3449
3450         /* Grab the subclass and look up the payload we are going to use */
3451         codec = ast_rtp_codecs_payload_code_tx(ast_rtp_instance_get_codecs(instance),
3452                 1, frame->subclass.format, 0);
3453         if (codec < 0) {
3454                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n",
3455                         ast_format_get_name(frame->subclass.format));
3456                 return -1;
3457         }
3458
3459         /* Note that we do not increase the ref count here as this pointer
3460          * will not be held by any thing explicitly. The format variable is
3461          * merely a convenience reference to frame->subclass.format */
3462         format = frame->subclass.format;
3463         if (ast_format_cmp(rtp->lasttxformat, format) == AST_FORMAT_CMP_NOT_EQUAL) {
3464                 /* Oh dear, if the format changed we will have to set up a new smoother */
3465                 if (option_debug > 0) {
3466                         ast_debug(1, "Ooh, format changed from %s to %s\n",
3467                                 ast_format_get_name(rtp->lasttxformat),
3468                                 ast_format_get_name(frame->subclass.format));
3469                 }
3470                 ao2_replace(rtp->lasttxformat, format);
3471                 if (rtp->smoother) {
3472                         ast_smoother_free(rtp->smoother);
3473                         rtp->smoother = NULL;
3474                 }
3475         }
3476
3477         /* If no smoother is present see if we have to set one up */
3478         if (!rtp->smoother && ast_format_can_be_smoothed(format)) {
3479                 unsigned int framing_ms = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(instance));
3480
3481                 if (framing_ms) {
3482                         rtp->smoother = ast_smoother_new((framing_ms * ast_format_get_minimum_bytes(format)) / ast_format_get_minimum_ms(format));
3483                         if (!rtp->smoother) {
3484                                 ast_log(LOG_WARNING, "Unable to create smoother: format %s ms: %u len: %u\n",
3485                                         ast_format_get_name(format), framing_ms, ast_format_get_minimum_bytes(format));
3486                                 return -1;
3487                         }
3488                 }
3489         }
3490
3491         /* Feed audio frames into the actual function that will create a frame and send it */
3492         if (rtp->smoother) {
3493                 struct ast_frame *f;
3494
3495                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
3496                         ast_smoother_feed_be(rtp->smoother, frame);
3497                 } else {
3498                         ast_smoother_feed(rtp->smoother, frame);
3499                 }
3500
3501                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
3502                                 ast_rtp_raw_write(instance, f, codec);
3503                 }
3504         } else {
3505                 int hdrlen = 12;
3506                 struct ast_frame *f = NULL;
3507
3508                 if (frame->offset < hdrlen) {
3509                         f = ast_frdup(frame);
3510                 } else {
3511                         f = frame;
3512                 }
3513                 if (f->data.ptr) {
3514                         ast_rtp_raw_write(instance, f, codec);
3515                 }
3516                 if (f != frame) {
3517                         ast_frfree(f);
3518                 }
3519
3520         }
3521
3522         return 0;
3523 }
3524
3525 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
3526 {
3527         struct timeval now;
3528         struct timeval tmp;
3529         double transit;
3530         double current_time;
3531         double d;
3532         double dtv;
3533         double prog;
3534         int rate = rtp_get_rate(rtp->f.subclass.format);
3535
3536         double normdev_rxjitter_current;
3537         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
3538                 gettimeofday(&rtp->rxcore, NULL);
3539                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
3540                 /* map timestamp to a real time */
3541                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
3542                 tmp = ast_samp2tv(timestamp, rate);
3543                 rtp->rxcore = ast_tvsub(rtp->rxcore, tmp);
3544                 /* Round to 0.1ms for nice, pretty timestamps */
3545                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
3546         }
3547
3548         gettimeofday(&now,NULL);
3549         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
3550         tmp = ast_samp2tv(timestamp, rate);
3551         *tv = ast_tvadd(rtp->rxcore, tmp);
3552
3553         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
3554         dtv = (double)rtp->drxcore + (double)(prog);
3555         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
3556         transit = current_time - dtv;
3557         d = transit - rtp->rxtransit;
3558         rtp->rxtransit = transit;
3559         if (d<0) {
3560                 d=-d;
3561         }
3562         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
3563         if (rtp->rtcp) {
3564                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
3565                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
3566                 if (rtp->rtcp->rxjitter_count == 1)
3567                         rtp->rtcp->minrxjitter = rtp->rxjitter;
3568                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
3569                         rtp->rtcp->minrxjitter = rtp->rxjitter;
3570
3571                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
3572                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
3573
3574                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
3575                 rtp->rtcp->rxjitter_count++;
3576         }
3577 }
3578
3579 static struct ast_frame *create_dtmf_frame(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
3580 {
3581         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3582         struct ast_sockaddr remote_address = { {0,} };
3583
3584         ast_rtp_instance_get_remote_address(instance, &remote_address);
3585
3586         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
3587                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n",
3588                           ast_sockaddr_stringify(&remote_address));
3589                 rtp->resp = 0;
3590                 rtp->dtmfsamples = 0;
3591                 return &ast_null_frame;
3592         }
3593         ast_debug(1, "Creating %s DTMF Frame: %d (%c), at %s\n",
3594                 type == AST_FRAME_DTMF_END ? "END" : "BEGIN",
3595                 rtp->resp, rtp->resp,
3596                 ast_sockaddr_stringify(&remote_address));
3597         if (rtp->resp == 'X') {
3598                 rtp->f.frametype = AST_FRAME_CONTROL;
3599                 rtp->f.subclass.integer = AST_CONTROL_FLASH;
3600         } else {
3601                 rtp->f.frametype = type;
3602                 rtp->f.subclass.integer = rtp->resp;
3603         }
3604         rtp->f.datalen = 0;
3605         rtp->f.samples = 0;
3606         rtp->f.mallocd = 0;
3607         rtp->f.src = "RTP";
3608         AST_LIST_NEXT(&rtp->f, frame_list) = NULL;
3609
3610         return &rtp->f;
3611 }
3612
3613 static void process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark, struct frame_list *frames)
3614 {
3615         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3616         struct ast_sockaddr remote_address = { {0,} };
3617         unsigned int event, event_end, samples;
3618         char resp = 0;
3619         struct ast_frame *f = NULL;
3620
3621         ast_rtp_instance_get_remote_address(instance, &remote_address);
3622
3623         /* Figure out event, event end, and samples */
3624         event = ntohl(*((unsigned int *)(data)));
3625         event >>= 24;
3626         event_end = ntohl(*((unsigned int *)(data)));
3627         event_end <<= 8;
3628         event_end >>= 24;
3629         samples = ntohl(*((unsigned int *)(data)));
3630         samples &= 0xFFFF;
3631
3632         if (rtp_debug_test_addr(&remote_address)) {
3633                 ast_verbose("Got  RTP RFC2833 from   %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6d, mark %d, event %08x, end %d, duration %-5.5u) \n",
3634                             ast_sockaddr_stringify(&remote_address),
3635                             payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
3636         }
3637
3638         /* Print out debug if turned on */
3639         if (rtpdebug)
3640                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
3641
3642         /* Figure out what digit was pressed */
3643         if (event < 10) {
3644                 resp = '0' + event;
3645         } else if (event < 11) {
3646                 resp = '*';
3647         } else if (event < 12) {
3648                 resp = '#';
3649         } else if (event < 16) {
3650                 resp = 'A' + (event - 12);
3651         } else if (event < 17) {        /* Event 16: Hook flash */
3652                 resp = 'X';
3653         } else {
3654                 /* Not a supported event */
3655                 ast_debug(1, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
3656                 return;
3657         }
3658
3659         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
3660                 if ((rtp->last_end_timestamp != timestamp) || (rtp->resp && rtp->resp != resp)) {
3661                         rtp->resp = resp;
3662                         rtp->dtmf_timeout = 0;
3663                         f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)));
3664                         f->len = 0;
3665                         rtp->last_end_timestamp = timestamp;
3666                         AST_LIST_INSERT_TAIL(frames, f, frame_list);
3667                 }
3668         } else {
3669                 /*  The duration parameter measures the complete
3670                     duration of the event (from the beginning) - RFC2833.
3671                     Account for the fact that duration is only 16 bits long
3672                     (about 8 seconds at 8000 Hz) and can wrap is digit
3673                     is hold for too long. */
3674                 unsigned int new_duration = rtp->dtmf_duration;
3675                 unsigned int last_duration = new_duration & 0xFFFF;
3676
3677                 if (last_duration > 64000 && samples < last_duration) {
3678                         new_duration += 0xFFFF + 1;
3679                 }
3680                 new_duration = (new_duration & ~0xFFFF) | samples;
3681
3682                 if (event_end & 0x80) {
3683                         /* End event */
3684                         if ((rtp->last_seqno != seqno) && (timestamp > rtp->last_end_timestamp)) {
3685                                 rtp->last_end_timestamp = timestamp;
3686                                 rtp->dtmf_duration = new_duration;
3687                                 rtp->resp = resp;
3688                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
3689                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.format)), ast_tv(0, 0));
3690                                 rtp->resp = 0;
3691                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
3692                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
3693                         } else if (rtpdebug) {
3694                                 ast_debug(1, "Dropping duplicate or out of order DTMF END frame (seqno: %u, ts %u, digit %c)\n",