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