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