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