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