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