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