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