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