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