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