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