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