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