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