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