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