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