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