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