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