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