9283f8083760076b8dc788a39170745a4beaa20c
[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         <support_level>core</support_level>
33  ***/
34
35 #include "asterisk.h"
36
37 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
38
39 #include <sys/time.h>
40 #include <signal.h>
41 #include <fcntl.h>
42
43 /* Asterisk discourages the use of bzero in favor of memset, in fact if you try to use bzero it will tell you to use memset. As a result bzero has to be undefined
44  * here since it is used internally by pjlib. The only other option would be to modify pjlib... which won't happen. */
45 #undef bzero
46 #define bzero bzero
47 #include "pjlib.h"
48 #include "pjlib-util.h"
49 #include "pjnath.h"
50
51 #include "asterisk/stun.h"
52 #include "asterisk/pbx.h"
53 #include "asterisk/frame.h"
54 #include "asterisk/channel.h"
55 #include "asterisk/acl.h"
56 #include "asterisk/config.h"
57 #include "asterisk/lock.h"
58 #include "asterisk/utils.h"
59 #include "asterisk/cli.h"
60 #include "asterisk/manager.h"
61 #include "asterisk/unaligned.h"
62 #include "asterisk/module.h"
63 #include "asterisk/rtp_engine.h"
64
65 #define MAX_TIMESTAMP_SKEW      640
66
67 #define RTP_SEQ_MOD     (1<<16) /*!< A sequence number can't be more than 16 bits */
68 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
69 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
70 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
71
72 #define DEFAULT_RTP_START 5000 /*!< Default port number to start allocating RTP ports from */
73 #define DEFAULT_RTP_END 31000  /*!< Default maximum port number to end allocating RTP ports at */
74
75 #define MINIMUM_RTP_PORT 1024 /*!< Minimum port number to accept */
76 #define MAXIMUM_RTP_PORT 65535 /*!< Maximum port number to accept */
77
78 #define DEFAULT_TURN_PORT 34780
79
80 #define TURN_ALLOCATION_WAIT_TIME 2000
81
82 #define RTCP_PT_FUR     192
83 #define RTCP_PT_SR      200
84 #define RTCP_PT_RR      201
85 #define RTCP_PT_SDES    202
86 #define RTCP_PT_BYE     203
87 #define RTCP_PT_APP     204
88
89 #define RTP_MTU         1200
90
91 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))      /*!< samples */
92
93 #define ZFONE_PROFILE_ID 0x505a
94
95 #define DEFAULT_LEARNING_MIN_SEQUENTIAL 4
96
97 enum strict_rtp_state {
98         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
99         STRICT_RTP_LEARN,    /*! Accept next packet as source */
100         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
101 };
102
103 #define DEFAULT_STRICT_RTP STRICT_RTP_CLOSED
104 #define DEFAULT_ICESUPPORT 1
105
106 extern struct ast_srtp_res *res_srtp;
107 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
108
109 static int rtpstart = DEFAULT_RTP_START;                        /*!< First port for RTP sessions (set in rtp.conf) */
110 static int rtpend = DEFAULT_RTP_END;                    /*!< Last port for RTP sessions (set in rtp.conf) */
111 static int rtpdebug;                    /*!< Are we debugging? */
112 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
113 static int rtcpstats;                   /*!< Are we debugging RTCP? */
114 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
115 static struct ast_sockaddr rtpdebugaddr;        /*!< Debug packets to/from this host */
116 static struct ast_sockaddr rtcpdebugaddr;       /*!< Debug RTCP packets to/from this host */
117 static int rtpdebugport;                /*< Debug only RTP packets from IP or IP+Port if port is > 0 */
118 static int rtcpdebugport;               /*< Debug only RTCP packets from IP or IP+Port if port is > 0 */
119 #ifdef SO_NO_CHECK
120 static int nochecksums;
121 #endif
122 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. */
123 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. */
124 static int icesupport = DEFAULT_ICESUPPORT;
125 static struct sockaddr_in stunaddr;
126 static pj_str_t turnaddr;
127 static int turnport = DEFAULT_TURN_PORT;
128 static pj_str_t turnusername;
129 static pj_str_t turnpassword;
130
131 /*! \brief Pool factory used by pjlib to allocate memory. */
132 static pj_caching_pool cachingpool;
133
134 /*! \brief Pool used by pjlib functions which require memory allocation. */
135 static pj_pool_t *pool;
136
137 /*! \brief I/O queue for TURN relay traffic */
138 static pj_ioqueue_t *ioqueue;
139
140 /*! \brief Timer heap for ICE and TURN stuff */
141 static pj_timer_heap_t *timerheap;
142
143 /*! \brief Worker thread for ICE/TURN */
144 static pj_thread_t *thread;
145
146 /*! \brief Notification that the ICE/TURN worker thread should stop */
147 static int worker_terminate;
148
149 #define FLAG_3389_WARNING               (1 << 0)
150 #define FLAG_NAT_ACTIVE                 (3 << 1)
151 #define FLAG_NAT_INACTIVE               (0 << 1)
152 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
153 #define FLAG_NEED_MARKER_BIT            (1 << 3)
154 #define FLAG_DTMF_COMPENSATE            (1 << 4)
155
156 #define TRANSPORT_SOCKET_RTP 1
157 #define TRANSPORT_SOCKET_RTCP 2
158 #define TRANSPORT_TURN_RTP 3
159 #define TRANSPORT_TURN_RTCP 4
160
161 #define COMPONENT_RTP 1
162 #define COMPONENT_RTCP 2
163
164 /*! \brief RTP session description */
165 struct ast_rtp {
166         int s;
167         struct ast_frame f;
168         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
169         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
170         unsigned int themssrc;          /*!< Their SSRC */
171         unsigned int rxssrc;
172         unsigned int lastts;
173         unsigned int lastrxts;
174         unsigned int lastividtimestamp;
175         unsigned int lastovidtimestamp;
176         unsigned int lastitexttimestamp;
177         unsigned int lastotexttimestamp;
178         unsigned int lasteventseqn;
179         int lastrxseqno;                /*!< Last received sequence number */
180         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
181         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
182         unsigned int rxcount;           /*!< How many packets have we received? */
183         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
184         unsigned int txcount;           /*!< How many packets have we sent? */
185         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
186         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
187         double rxjitter;                /*!< Interarrival jitter at the moment in seconds */
188         double rxtransit;               /*!< Relative transit time for previous packet */
189         struct ast_format lasttxformat;
190         struct ast_format lastrxformat;
191
192         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
193         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
194         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
195
196         /* DTMF Reception Variables */
197         char resp;                        /*!< The current digit being processed */
198         unsigned int last_seqno;          /*!< The last known sequence number for any DTMF packet */
199         unsigned int last_end_timestamp;  /*!< The last known timestamp received from an END packet */
200         unsigned int dtmf_duration;       /*!< Total duration in samples since the digit start event */
201         unsigned int dtmf_timeout;        /*!< When this timestamp is reached we consider END frame lost and forcibly abort digit */
202         unsigned int dtmfsamples;
203         enum ast_rtp_dtmf_mode dtmfmode;  /*!< The current DTMF mode of the RTP stream */
204         /* DTMF Transmission Variables */
205         unsigned int lastdigitts;
206         char sending_digit;     /*!< boolean - are we sending digits */
207         char send_digit;        /*!< digit we are sending */
208         int send_payload;
209         int send_duration;
210         unsigned int flags;
211         struct timeval rxcore;
212         struct timeval txcore;
213         double drxcore;                 /*!< The double representation of the first received packet */
214         struct timeval lastrx;          /*!< timeval when we last received a packet */
215         struct timeval dtmfmute;
216         struct ast_smoother *smoother;
217         int *ioid;
218         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
219         unsigned short rxseqno;
220         struct ast_sched_context *sched;
221         struct io_context *io;
222         void *data;
223         struct ast_rtcp *rtcp;
224         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
225
226         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
227         struct ast_sockaddr strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
228         struct ast_sockaddr alt_rtp_address; /*!<Alternate remote address information */
229
230         /*
231          * Learning mode values based on pjmedia's probation mode.  Many of these values are redundant to the above,
232          * but these are in place to keep learning mode sequence values sealed from their normal counterparts.
233          */
234         uint16_t learning_max_seq;              /*!< Highest sequence number heard */
235         int learning_probation;         /*!< Sequential packets untill source is valid */
236
237         struct rtp_red *red;
238
239         pj_ice_sess *ice;           /*!< ICE session */
240         pj_turn_sock *turn_rtp;     /*!< RTP TURN relay */
241         pj_turn_sock *turn_rtcp;    /*!< RTCP TURN relay */
242         ast_mutex_t lock;           /*!< Lock for synchronization purposes */
243         pj_turn_state_t turn_state; /*!< Current state of the TURN relay session */
244         ast_cond_t cond;            /*!< Condition for signaling */
245         unsigned int passthrough:1; /*!< Bit to indicate that the received packet should be passed through */
246         unsigned int ice_started:1; /*!< Bit to indicate ICE connectivity checks have started */
247
248         char remote_ufrag[256];  /*!< The remote ICE username */
249         char remote_passwd[256]; /*!< The remote ICE password */
250
251         char local_ufrag[256];  /*!< The local ICE username */
252         char local_passwd[256]; /*!< The local ICE password */
253
254         struct ao2_container *local_candidates;   /*!< The local ICE candidates */
255         struct ao2_container *remote_candidates;  /*!< The remote ICE candidates */
256 };
257
258 /*!
259  * \brief Structure defining an RTCP session.
260  *
261  * The concept "RTCP session" is not defined in RFC 3550, but since
262  * this structure is analogous to ast_rtp, which tracks a RTP session,
263  * it is logical to think of this as a RTCP session.
264  *
265  * RTCP packet is defined on page 9 of RFC 3550.
266  *
267  */
268 struct ast_rtcp {
269         int rtcp_info;
270         int s;                          /*!< Socket */
271         struct ast_sockaddr us;         /*!< Socket representation of the local endpoint. */
272         struct ast_sockaddr them;       /*!< Socket representation of the remote endpoint. */
273         unsigned int soc;               /*!< What they told us */
274         unsigned int spc;               /*!< What they told us */
275         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
276         struct timeval rxlsr;           /*!< Time when we got their last SR */
277         struct timeval txlsr;           /*!< Time when we sent or last SR*/
278         unsigned int expected_prior;    /*!< no. packets in previous interval */
279         unsigned int received_prior;    /*!< no. packets received in previous interval */
280         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
281         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
282         unsigned int sr_count;          /*!< number of SRs we've sent */
283         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
284         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
285         double rtt;                     /*!< Last reported rtt */
286         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
287         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
288
289         double reported_maxjitter;
290         double reported_minjitter;
291         double reported_normdev_jitter;
292         double reported_stdev_jitter;
293         unsigned int reported_jitter_count;
294
295         double reported_maxlost;
296         double reported_minlost;
297         double reported_normdev_lost;
298         double reported_stdev_lost;
299
300         double rxlost;
301         double maxrxlost;
302         double minrxlost;
303         double normdev_rxlost;
304         double stdev_rxlost;
305         unsigned int rxlost_count;
306
307         double maxrxjitter;
308         double minrxjitter;
309         double normdev_rxjitter;
310         double stdev_rxjitter;
311         unsigned int rxjitter_count;
312         double maxrtt;
313         double minrtt;
314         double normdevrtt;
315         double stdevrtt;
316         unsigned int rtt_count;
317 };
318
319 struct rtp_red {
320         struct ast_frame t140;  /*!< Primary data  */
321         struct ast_frame t140red;   /*!< Redundant t140*/
322         unsigned char pt[AST_RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
323         unsigned char ts[AST_RED_MAX_GENERATION]; /*!< Time stamps */
324         unsigned char len[AST_RED_MAX_GENERATION]; /*!< length of each generation */
325         int num_gen; /*!< Number of generations */
326         int schedid; /*!< Timer id */
327         int ti; /*!< How long to buffer data before send */
328         unsigned char t140red_data[64000];
329         unsigned char buf_data[64000]; /*!< buffered primary data */
330         int hdrlen;
331         long int prev_ts;
332 };
333
334 AST_LIST_HEAD_NOLOCK(frame_list, ast_frame);
335
336 /* Forward Declarations */
337 static int ast_rtp_new(struct ast_rtp_instance *instance, struct ast_sched_context *sched, struct ast_sockaddr *addr, void *data);
338 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
339 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
340 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
341 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration);
342 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode);
343 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance);
344 static void ast_rtp_update_source(struct ast_rtp_instance *instance);
345 static void ast_rtp_change_source(struct ast_rtp_instance *instance);
346 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
347 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp);
348 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
349 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp);
350 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr);
351 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr);
352 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
353 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
354 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
355 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
356 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
357 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username);
358 static void ast_rtp_stop(struct ast_rtp_instance *instance);
359 static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char* desc);
360 static int ast_rtp_sendcng(struct ast_rtp_instance *instance, int level);
361
362 /*! \brief Destructor for locally created ICE candidates */
363 static void ast_rtp_ice_candidate_destroy(void *obj)
364 {
365         struct ast_rtp_engine_ice_candidate *candidate = obj;
366
367         if (candidate->foundation) {
368                 ast_free(candidate->foundation);
369         }
370
371         if (candidate->transport) {
372                 ast_free(candidate->transport);
373         }
374 }
375
376 static void ast_rtp_ice_set_authentication(struct ast_rtp_instance *instance, const char *ufrag, const char *password)
377 {
378         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
379
380         if (!ast_strlen_zero(ufrag)) {
381                 ast_copy_string(rtp->remote_ufrag, ufrag, sizeof(rtp->remote_ufrag));
382         }
383
384         if (!ast_strlen_zero(password)) {
385                 ast_copy_string(rtp->remote_passwd, password, sizeof(rtp->remote_passwd));
386         }
387 }
388
389 static void ast_rtp_ice_add_remote_candidate(struct ast_rtp_instance *instance, const struct ast_rtp_engine_ice_candidate *candidate)
390 {
391         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
392         struct ast_rtp_engine_ice_candidate *remote_candidate;
393
394         if (!rtp->remote_candidates && !(rtp->remote_candidates = ao2_container_alloc(1, NULL, NULL))) {
395                 return;
396         }
397
398         /* If this is going to exceed the maximum number of ICE candidates don't even add it */
399         if (ao2_container_count(rtp->remote_candidates) == PJ_ICE_MAX_CAND) {
400                 return;
401         }
402
403         if (!(remote_candidate = ao2_alloc(sizeof(*remote_candidate), ast_rtp_ice_candidate_destroy))) {
404                 return;
405         }
406
407         remote_candidate->foundation = ast_strdup(candidate->foundation);
408         remote_candidate->id = candidate->id;
409         remote_candidate->transport = ast_strdup(candidate->transport);
410         remote_candidate->priority = candidate->priority;
411         ast_sockaddr_copy(&remote_candidate->address, &candidate->address);
412         ast_sockaddr_copy(&remote_candidate->relay_address, &candidate->relay_address);
413         remote_candidate->type = candidate->type;
414
415         ao2_link(rtp->remote_candidates, remote_candidate);
416         ao2_ref(remote_candidate, -1);
417 }
418
419 AST_THREADSTORAGE(pj_thread_storage);
420
421 /*! \brief Function used to check if the calling thread is registered with pjlib. If it is not it will be registered. */
422 static void pj_thread_register_check(void)
423 {
424         pj_thread_desc *desc;
425         pj_thread_t *thread;
426
427         if (pj_thread_is_registered() == PJ_TRUE) {
428                 return;
429         }
430
431         desc = ast_threadstorage_get(&pj_thread_storage, sizeof(pj_thread_desc));
432         if (!desc) {
433                 ast_log(LOG_ERROR, "Could not get thread desc from thread-local storage. Expect awful things to occur\n");
434                 return;
435         }
436         pj_bzero(*desc, sizeof(*desc));
437
438         if (pj_thread_register("Asterisk Thread", *desc, &thread) != PJ_SUCCESS) {
439                 ast_log(LOG_ERROR, "Coudln't register thread with PJLIB.\n");
440         }
441         return;
442 }
443
444 /*! \brief Helper function which updates an ast_sockaddr with the candidate used for the component */
445 static void update_address_with_ice_candidate(struct ast_rtp *rtp, int component, struct ast_sockaddr *cand_address)
446 {
447         char address[PJ_INET6_ADDRSTRLEN];
448
449         if (!rtp->ice || (component < 1) || !rtp->ice->comp[component - 1].valid_check) {
450                 return;
451         }
452
453         ast_sockaddr_parse(cand_address, pj_sockaddr_print(&rtp->ice->comp[component - 1].valid_check->rcand->addr, address, sizeof(address), 0), 0);
454         ast_sockaddr_set_port(cand_address, pj_sockaddr_get_port(&rtp->ice->comp[component - 1].valid_check->rcand->addr));
455 }
456
457 static void ast_rtp_ice_start(struct ast_rtp_instance *instance)
458 {
459         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
460         pj_str_t ufrag = pj_str(rtp->remote_ufrag), passwd = pj_str(rtp->remote_passwd);
461         pj_ice_sess_cand candidates[PJ_ICE_MAX_CAND];
462         struct ao2_iterator i;
463         struct ast_rtp_engine_ice_candidate *candidate;
464         int cand_cnt = 0;
465
466         if (!rtp->ice || !rtp->remote_candidates || rtp->ice_started) {
467                 return;
468         }
469
470         pj_thread_register_check();
471
472         i = ao2_iterator_init(rtp->remote_candidates, 0);
473
474         while ((candidate = ao2_iterator_next(&i)) && (cand_cnt < PJ_ICE_MAX_CAND)) {
475                 pj_str_t address;
476
477                 pj_strdup2(rtp->ice->pool, &candidates[cand_cnt].foundation, candidate->foundation);
478                 candidates[cand_cnt].comp_id = candidate->id;
479                 candidates[cand_cnt].prio = candidate->priority;
480
481                 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&address, ast_sockaddr_stringify(&candidate->address)), &candidates[cand_cnt].addr);
482
483                 if (!ast_sockaddr_isnull(&candidate->relay_address)) {
484                         pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&address, ast_sockaddr_stringify(&candidate->relay_address)), &candidates[cand_cnt].rel_addr);
485                 }
486
487                 if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_HOST) {
488                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_HOST;
489                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_SRFLX) {
490                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_SRFLX;
491                 } else if (candidate->type == AST_RTP_ICE_CANDIDATE_TYPE_RELAYED) {
492                         candidates[cand_cnt].type = PJ_ICE_CAND_TYPE_RELAYED;
493                 }
494
495                 if (candidate->id == COMPONENT_RTP && rtp->turn_rtp) {
496                         pj_turn_sock_set_perm(rtp->turn_rtp, 1, &candidates[cand_cnt].addr, 1);
497                 } else if (candidate->id == COMPONENT_RTCP && rtp->turn_rtcp) {
498                         pj_turn_sock_set_perm(rtp->turn_rtcp, 1, &candidates[cand_cnt].addr, 1);
499                 }
500
501                 cand_cnt++;
502         }
503
504         ao2_iterator_destroy(&i);
505
506         if (pj_ice_sess_create_check_list(rtp->ice, &ufrag, &passwd, ao2_container_count(rtp->remote_candidates), &candidates[0]) == PJ_SUCCESS) {
507                 pj_ice_sess_start_check(rtp->ice);
508                 pj_timer_heap_poll(timerheap, NULL);
509                 rtp->ice_started = 1;
510         }
511 }
512
513 static void ast_rtp_ice_stop(struct ast_rtp_instance *instance)
514 {
515         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
516
517         if (!rtp->ice) {
518                 return;
519         }
520
521         pj_thread_register_check();
522
523         pj_ice_sess_destroy(rtp->ice);
524         rtp->ice = NULL;
525 }
526
527 static const char *ast_rtp_ice_get_ufrag(struct ast_rtp_instance *instance)
528 {
529         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
530
531         return rtp->local_ufrag;
532 }
533
534 static const char *ast_rtp_ice_get_password(struct ast_rtp_instance *instance)
535 {
536         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
537
538         return rtp->local_passwd;
539 }
540
541 static struct ao2_container *ast_rtp_ice_get_local_candidates(struct ast_rtp_instance *instance)
542 {
543         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
544
545         if (rtp->local_candidates) {
546                 ao2_ref(rtp->local_candidates, +1);
547         }
548
549         return rtp->local_candidates;
550 }
551
552 static void ast_rtp_ice_lite(struct ast_rtp_instance *instance)
553 {
554         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
555
556         if (!rtp->ice) {
557                 return;
558         }
559
560         pj_thread_register_check();
561
562         pj_ice_sess_change_role(rtp->ice, PJ_ICE_SESS_ROLE_CONTROLLING);
563 }
564
565 static int ice_candidate_cmp(void *obj, void *arg, int flags)
566 {
567         struct ast_rtp_engine_ice_candidate *candidate1 = obj, *candidate2 = arg;
568
569         if ((strcmp(candidate1->foundation, candidate2->foundation)) ||
570             (candidate1->id != candidate2->id) ||
571             (ast_sockaddr_cmp(&candidate1->address, &candidate2->address)) ||
572             (candidate1->type != candidate1->type)) {
573                 return 0;
574         }
575
576         return CMP_MATCH | CMP_STOP;
577 }
578
579 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,
580                                         const pj_sockaddr_t *addr, const pj_sockaddr_t *base_addr, const pj_sockaddr_t *rel_addr, int addr_len)
581 {
582         pj_str_t foundation;
583         struct ast_rtp_engine_ice_candidate *candidate, *existing;
584         char address[PJ_INET6_ADDRSTRLEN];
585
586         pj_thread_register_check();
587
588         pj_ice_calc_foundation(rtp->ice->pool, &foundation, type, addr);
589
590         if (!rtp->local_candidates && !(rtp->local_candidates = ao2_container_alloc(1, NULL, ice_candidate_cmp))) {
591                 return;
592         }
593
594         if (!(candidate = ao2_alloc(sizeof(*candidate), ast_rtp_ice_candidate_destroy))) {
595                 return;
596         }
597
598         candidate->foundation = ast_strndup(pj_strbuf(&foundation), pj_strlen(&foundation));
599         candidate->id = comp_id;
600         candidate->transport = ast_strdup("UDP");
601
602         ast_sockaddr_parse(&candidate->address, pj_sockaddr_print(addr, address, sizeof(address), 0), 0);
603         ast_sockaddr_set_port(&candidate->address, pj_sockaddr_get_port(addr));
604
605         if (rel_addr) {
606                 ast_sockaddr_parse(&candidate->relay_address, pj_sockaddr_print(rel_addr, address, sizeof(address), 0), 0);
607                 ast_sockaddr_set_port(&candidate->relay_address, pj_sockaddr_get_port(rel_addr));
608         }
609
610         if (type == PJ_ICE_CAND_TYPE_HOST) {
611                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
612         } else if (type == PJ_ICE_CAND_TYPE_SRFLX) {
613                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
614         } else if (type == PJ_ICE_CAND_TYPE_RELAYED) {
615                 candidate->type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
616         }
617
618         if ((existing = ao2_find(rtp->local_candidates, candidate, OBJ_POINTER))) {
619                 ao2_ref(existing, -1);
620                 ao2_ref(candidate, -1);
621                 return;
622         }
623
624         if (pj_ice_sess_add_cand(rtp->ice, comp_id, transport_id, type, local_pref, &foundation, addr, addr, rel_addr, addr_len, NULL) != PJ_SUCCESS) {
625                 ao2_ref(candidate, -1);
626                 return;
627         }
628
629         /* By placing the candidate into the ICE session it will have produced the priority, so update the local candidate with it */
630         candidate->priority = rtp->ice->lcand[rtp->ice->lcand_cnt - 1].prio;
631
632         ao2_link(rtp->local_candidates, candidate);
633         ao2_ref(candidate, -1);
634 }
635
636 static char *generate_random_string(char *buf, size_t size)
637 {
638         long val[4];
639         int x;
640
641         for (x=0; x<4; x++)
642                 val[x] = ast_random();
643         snprintf(buf, size, "%08lx%08lx%08lx%08lx", val[0], val[1], val[2], val[3]);
644
645         return buf;
646 }
647
648 /* ICE RTP Engine interface declaration */
649 static struct ast_rtp_engine_ice ast_rtp_ice = {
650         .set_authentication = ast_rtp_ice_set_authentication,
651         .add_remote_candidate = ast_rtp_ice_add_remote_candidate,
652         .start = ast_rtp_ice_start,
653         .stop = ast_rtp_ice_stop,
654         .get_ufrag = ast_rtp_ice_get_ufrag,
655         .get_password = ast_rtp_ice_get_password,
656         .get_local_candidates = ast_rtp_ice_get_local_candidates,
657         .ice_lite = ast_rtp_ice_lite,
658 };
659
660 /* RTP Engine Declaration */
661 static struct ast_rtp_engine asterisk_rtp_engine = {
662         .name = "asterisk",
663         .new = ast_rtp_new,
664         .destroy = ast_rtp_destroy,
665         .dtmf_begin = ast_rtp_dtmf_begin,
666         .dtmf_end = ast_rtp_dtmf_end,
667         .dtmf_end_with_duration = ast_rtp_dtmf_end_with_duration,
668         .dtmf_mode_set = ast_rtp_dtmf_mode_set,
669         .dtmf_mode_get = ast_rtp_dtmf_mode_get,
670         .update_source = ast_rtp_update_source,
671         .change_source = ast_rtp_change_source,
672         .write = ast_rtp_write,
673         .read = ast_rtp_read,
674         .prop_set = ast_rtp_prop_set,
675         .fd = ast_rtp_fd,
676         .remote_address_set = ast_rtp_remote_address_set,
677         .alt_remote_address_set = ast_rtp_alt_remote_address_set,
678         .red_init = rtp_red_init,
679         .red_buffer = rtp_red_buffer,
680         .local_bridge = ast_rtp_local_bridge,
681         .get_stat = ast_rtp_get_stat,
682         .dtmf_compatible = ast_rtp_dtmf_compatible,
683         .stun_request = ast_rtp_stun_request,
684         .stop = ast_rtp_stop,
685         .qos = ast_rtp_qos_set,
686         .sendcng = ast_rtp_sendcng,
687         .ice = &ast_rtp_ice,
688 };
689
690 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)
691 {
692         struct ast_rtp *rtp = ice->user_data;
693
694         /* 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
695          * returns */
696         rtp->passthrough = 1;
697 }
698
699 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)
700 {
701         struct ast_rtp *rtp = ice->user_data;
702         pj_status_t status = PJ_EINVALIDOP;
703         pj_ssize_t _size = (pj_ssize_t)size;
704
705         if (transport_id == TRANSPORT_SOCKET_RTP) {
706                 /* Traffic is destined to go right out the RTP socket we already have */
707                 status = pj_sock_sendto(rtp->s, pkt, &_size, 0, dst_addr, dst_addr_len);
708                 /* sendto on a connectionless socket should send all the data, or none at all */
709                 ast_assert(_size == size || status != PJ_SUCCESS);
710         } else if (transport_id == TRANSPORT_SOCKET_RTCP) {
711                 /* Traffic is destined to go right out the RTCP socket we already have */
712                 if (rtp->rtcp) {
713                         status = pj_sock_sendto(rtp->rtcp->s, pkt, &_size, 0, dst_addr, dst_addr_len);
714                         /* sendto on a connectionless socket should send all the data, or none at all */
715                         ast_assert(_size == size || status != PJ_SUCCESS);
716                 } else {
717                         status = PJ_SUCCESS;
718                 }
719         } else if (transport_id == TRANSPORT_TURN_RTP) {
720                 /* Traffic is going through the RTP TURN relay */
721                 if (rtp->turn_rtp) {
722                         status = pj_turn_sock_sendto(rtp->turn_rtp, pkt, size, dst_addr, dst_addr_len);
723                 }
724         } else if (transport_id == TRANSPORT_TURN_RTCP) {
725                 /* Traffic is going through the RTCP TURN relay */
726                 if (rtp->turn_rtcp) {
727                         status = pj_turn_sock_sendto(rtp->turn_rtcp, pkt, size, dst_addr, dst_addr_len);
728                 }
729         }
730
731         return status;
732 }
733
734 /* ICE Session interface declaration */
735 static pj_ice_sess_cb ast_rtp_ice_sess_cb = {
736         .on_rx_data = ast_rtp_on_ice_rx_data,
737         .on_tx_pkt = ast_rtp_on_ice_tx_pkt,
738 };
739
740 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)
741 {
742         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
743         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
744         struct ast_sockaddr dest = { { 0, }, };
745
746         ast_rtp_instance_get_local_address(instance, &dest);
747
748         ast_sendto(rtp->s, pkt, pkt_len, 0, &dest);
749 }
750
751 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)
752 {
753         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
754         struct ast_rtp *rtp = NULL;
755
756         /* If this is a leftover from an already destroyed RTP instance just ignore the state change */
757         if (!instance) {
758                 return;
759         }
760
761         rtp = ast_rtp_instance_get_data(instance);
762
763         /* If the TURN session is being destroyed we need to remove it from the RTP instance */
764         if (new_state == PJ_TURN_STATE_DESTROYING) {
765                 rtp->turn_rtp = NULL;
766                 return;
767         }
768
769         /* We store the new state so the other thread can actually handle it */
770         ast_mutex_lock(&rtp->lock);
771         rtp->turn_state = new_state;
772
773         /* If this is a state that the main thread should be notified about do so */
774         if (new_state == PJ_TURN_STATE_READY || new_state == PJ_TURN_STATE_DEALLOCATING || new_state == PJ_TURN_STATE_DEALLOCATED) {
775                 ast_cond_signal(&rtp->cond);
776         }
777
778         ast_mutex_unlock(&rtp->lock);
779 }
780
781 /* RTP TURN Socket interface declaration */
782 static pj_turn_sock_cb ast_rtp_turn_rtp_sock_cb = {
783         .on_rx_data = ast_rtp_on_turn_rx_rtp_data,
784         .on_state = ast_rtp_on_turn_rtp_state,
785 };
786
787 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)
788 {
789         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
790         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
791
792         ast_sendto(rtp->rtcp->s, pkt, pkt_len, 0, &rtp->rtcp->us);
793 }
794
795 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)
796 {
797         struct ast_rtp_instance *instance = pj_turn_sock_get_user_data(turn_sock);
798         struct ast_rtp *rtp = NULL;
799
800         /* If this is a leftover from an already destroyed RTP instance just ignore the state change */
801         if (!instance) {
802                 return;
803         }
804
805         rtp = ast_rtp_instance_get_data(instance);
806
807         /* If the TURN session is being destroyed we need to remove it from the RTP instance */
808         if (new_state == PJ_TURN_STATE_DESTROYING) {
809                 rtp->turn_rtcp = NULL;
810                 return;
811         }
812
813         /* We store the new state so the other thread can actually handle it */
814         ast_mutex_lock(&rtp->lock);
815         rtp->turn_state = new_state;
816
817         /* If this is a state that the main thread should be notified about do so */
818         if (new_state == PJ_TURN_STATE_READY || new_state == PJ_TURN_STATE_DEALLOCATING || new_state == PJ_TURN_STATE_DEALLOCATED) {
819                 ast_cond_signal(&rtp->cond);
820         }
821
822        ast_mutex_unlock(&rtp->lock);
823 }
824
825 /* RTCP TURN Socket interface declaration */
826 static pj_turn_sock_cb ast_rtp_turn_rtcp_sock_cb = {
827         .on_rx_data = ast_rtp_on_turn_rx_rtcp_data,
828         .on_state = ast_rtp_on_turn_rtcp_state,
829 };
830
831 /*! \brief Worker thread for I/O queue and timerheap */
832 static int ice_worker_thread(void *data)
833 {
834         while (!worker_terminate) {
835                 const pj_time_val delay = {0, 10};
836
837                 pj_ioqueue_poll(ioqueue, &delay);
838
839                 pj_timer_heap_poll(timerheap, NULL);
840         }
841
842         return 0;
843 }
844
845 static inline int rtp_debug_test_addr(struct ast_sockaddr *addr)
846 {
847         if (!rtpdebug) {
848                 return 0;
849         }
850         if (!ast_sockaddr_isnull(&rtpdebugaddr)) {
851                 if (rtpdebugport) {
852                         return (ast_sockaddr_cmp(&rtpdebugaddr, addr) == 0); /* look for RTP packets from IP+Port */
853                 } else {
854                         return (ast_sockaddr_cmp_addr(&rtpdebugaddr, addr) == 0); /* only look for RTP packets from IP */
855                 }
856         }
857
858         return 1;
859 }
860
861 static inline int rtcp_debug_test_addr(struct ast_sockaddr *addr)
862 {
863         if (!rtcpdebug) {
864                 return 0;
865         }
866         if (!ast_sockaddr_isnull(&rtcpdebugaddr)) {
867                 if (rtcpdebugport) {
868                         return (ast_sockaddr_cmp(&rtcpdebugaddr, addr) == 0); /* look for RTCP packets from IP+Port */
869                 } else {
870                         return (ast_sockaddr_cmp_addr(&rtcpdebugaddr, addr) == 0); /* only look for RTCP packets from IP */
871                 }
872         }
873
874         return 1;
875 }
876
877 static int __rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp)
878 {
879         int len;
880         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
881         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
882
883         if ((len = ast_recvfrom(rtcp ? rtp->rtcp->s : rtp->s, buf, size, flags, sa)) < 0) {
884            return len;
885         }
886
887         if (rtp->ice) {
888                 pj_str_t combined = pj_str(ast_sockaddr_stringify(sa));
889                 pj_sockaddr address;
890                 pj_status_t status;
891
892                 pj_thread_register_check();
893
894                 pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &combined, &address);
895
896                 status = pj_ice_sess_on_rx_pkt(rtp->ice, rtcp ? COMPONENT_RTCP : COMPONENT_RTP,
897                         rtcp ? TRANSPORT_SOCKET_RTCP : TRANSPORT_SOCKET_RTP, buf, len, &address,
898                         pj_sockaddr_get_len(&address));
899                 if (status != PJ_SUCCESS) {
900                         char buf[100];
901
902                         pj_strerror(status, buf, sizeof(buf));
903                         ast_log(LOG_WARNING, "PJ ICE Rx error status code: %d '%s'.\n",
904                                 (int) status, buf);
905                         return -1;
906                 }
907                 if (!rtp->passthrough) {
908                         return 0;
909                 }
910                 rtp->passthrough = 0;
911         }
912
913         if (res_srtp && srtp && res_srtp->unprotect(srtp, buf, &len, rtcp) < 0) {
914            return -1;
915         }
916
917         return len;
918 }
919
920 static int rtcp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
921 {
922         return __rtp_recvfrom(instance, buf, size, flags, sa, 1);
923 }
924
925 static int rtp_recvfrom(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa)
926 {
927         return __rtp_recvfrom(instance, buf, size, flags, sa, 0);
928 }
929
930 static int __rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int rtcp, int *ice)
931 {
932         int len = size;
933         void *temp = buf;
934         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
935         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
936
937         *ice = 0;
938
939         if (res_srtp && srtp && res_srtp->protect(srtp, &temp, &len, rtcp) < 0) {
940                 return -1;
941         }
942
943         if (rtp->ice) {
944                 pj_thread_register_check();
945
946                 if (pj_ice_sess_send_data(rtp->ice, rtcp ? COMPONENT_RTCP : COMPONENT_RTP, temp, len) == PJ_SUCCESS) {
947                         *ice = 1;
948                         return 0;
949                 }
950         }
951
952         return ast_sendto(rtcp ? rtp->rtcp->s : rtp->s, temp, len, flags, sa);
953 }
954
955 static int rtcp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
956 {
957         return __rtp_sendto(instance, buf, size, flags, sa, 1, ice);
958 }
959
960 static int rtp_sendto(struct ast_rtp_instance *instance, void *buf, size_t size, int flags, struct ast_sockaddr *sa, int *ice)
961 {
962         return __rtp_sendto(instance, buf, size, flags, sa, 0, ice);
963 }
964
965 static int rtp_get_rate(struct ast_format *format)
966 {
967         return (format->id == AST_FORMAT_G722) ? 8000 : ast_format_rate(format);
968 }
969
970 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
971 {
972         unsigned int interval;
973         /*! \todo XXX Do a more reasonable calculation on this one
974          * Look in RFC 3550 Section A.7 for an example*/
975         interval = rtcpinterval;
976         return interval;
977 }
978
979 /*! \brief Calculate normal deviation */
980 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
981 {
982         normdev = normdev * sample_count + sample;
983         sample_count++;
984
985         return normdev / sample_count;
986 }
987
988 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
989 {
990 /*
991                 for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
992                 return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
993                 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
994                 optimized formula
995 */
996 #define SQUARE(x) ((x) * (x))
997
998         stddev = sample_count * stddev;
999         sample_count++;
1000
1001         return stddev +
1002                 ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) +
1003                 ( SQUARE(sample - normdev_curent) / sample_count );
1004
1005 #undef SQUARE
1006 }
1007
1008 static int create_new_socket(const char *type, int af)
1009 {
1010         int sock = socket(af, SOCK_DGRAM, 0);
1011
1012         if (sock < 0) {
1013                 if (!type) {
1014                         type = "RTP/RTCP";
1015                 }
1016                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
1017         } else {
1018                 long flags = fcntl(sock, F_GETFL);
1019                 fcntl(sock, F_SETFL, flags | O_NONBLOCK);
1020 #ifdef SO_NO_CHECK
1021                 if (nochecksums) {
1022                         setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1023                 }
1024 #endif
1025         }
1026
1027         return sock;
1028 }
1029
1030 /*!
1031  * \internal
1032  * \brief Initializes sequence values and probation for learning mode.
1033  * \note This is an adaptation of pjmedia's pjmedia_rtp_seq_init function.
1034  *
1035  * \param rtp pointer to rtp struct used with the received rtp packet.
1036  * \param seq sequence number read from the rtp header
1037  */
1038 static void rtp_learning_seq_init(struct ast_rtp *rtp, uint16_t seq)
1039 {
1040         rtp->learning_max_seq = seq - 1;
1041         rtp->learning_probation = learning_min_sequential;
1042 }
1043
1044 /*!
1045  * \internal
1046  * \brief Updates sequence information for learning mode and determines if probation/learning mode should remain in effect.
1047  * \note This function was adapted from pjmedia's pjmedia_rtp_seq_update function.
1048  *
1049  * \param rtp pointer to rtp struct used with the received rtp packet.
1050  * \param seq sequence number read from the rtp header
1051  * \return boolean value indicating if probation mode is active at the end of the function
1052  */
1053 static int rtp_learning_rtp_seq_update(struct ast_rtp *rtp, uint16_t seq)
1054 {
1055         int probation = 1;
1056
1057         ast_debug(1, "%p -- probation = %d, seq = %d\n", rtp, rtp->learning_probation, seq);
1058
1059         if (seq == rtp->learning_max_seq + 1) {
1060                 /* packet is in sequence */
1061                 rtp->learning_probation--;
1062                 rtp->learning_max_seq = seq;
1063                 if (rtp->learning_probation == 0) {
1064                         probation = 0;
1065                 }
1066         } else {
1067                 rtp->learning_probation = learning_min_sequential - 1;
1068                 rtp->learning_max_seq = seq;
1069         }
1070
1071         return probation;
1072 }
1073
1074 static void rtp_add_candidates_to_ice(struct ast_rtp_instance *instance, struct ast_rtp *rtp, struct ast_sockaddr *addr, int port, int component,
1075                                       int transport, const pj_turn_sock_cb *turn_cb, pj_turn_sock **turn_sock)
1076 {
1077         pj_sockaddr address[16];
1078         unsigned int count = PJ_ARRAY_SIZE(address), pos = 0;
1079
1080         /* Add all the local interface IP addresses */
1081         pj_enum_ip_interface(ast_sockaddr_is_ipv4(addr) ? pj_AF_INET() : pj_AF_INET6(), &count, address);
1082
1083         for (pos = 0; pos < count; pos++) {
1084                 pj_sockaddr_set_port(&address[pos], port);
1085                 ast_rtp_ice_add_cand(rtp, component, transport, PJ_ICE_CAND_TYPE_HOST, 65535, &address[pos], &address[pos], NULL,
1086                                      pj_sockaddr_get_len(&address[pos]));
1087         }
1088
1089         /* If configured to use a STUN server to get our external mapped address do so */
1090         if (stunaddr.sin_addr.s_addr && ast_sockaddr_is_ipv4(addr)) {
1091                 struct sockaddr_in answer;
1092
1093                 if (!ast_stun_request(rtp->s, &stunaddr, NULL, &answer)) {
1094                         pj_str_t mapped = pj_str(ast_strdupa(ast_inet_ntoa(answer.sin_addr)));
1095
1096                         pj_sockaddr_init(pj_AF_INET(), &address[0], &mapped, ntohs(answer.sin_port));
1097
1098                         ast_rtp_ice_add_cand(rtp, component, transport, PJ_ICE_CAND_TYPE_SRFLX, 65535, &address[0], &address[0],
1099                                              NULL, pj_sockaddr_get_len(&address[0]));
1100                 }
1101         }
1102
1103         /* If configured to use a TURN relay create a session and allocate */
1104         if (pj_strlen(&turnaddr) && pj_turn_sock_create(&rtp->ice->stun_cfg, ast_sockaddr_is_ipv4(addr) ? pj_AF_INET() : pj_AF_INET6(), PJ_TURN_TP_TCP,
1105                                                         turn_cb, NULL, instance, turn_sock) == PJ_SUCCESS) {
1106                 pj_stun_auth_cred cred = { 0, };
1107                 struct timeval wait = ast_tvadd(ast_tvnow(), ast_samp2tv(TURN_ALLOCATION_WAIT_TIME, 1000));
1108                 struct timespec ts = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000, };
1109
1110                 cred.type = PJ_STUN_AUTH_CRED_STATIC;
1111                 cred.data.static_cred.username = turnusername;
1112                 cred.data.static_cred.data_type = PJ_STUN_PASSWD_PLAIN;
1113                 cred.data.static_cred.data = turnpassword;
1114
1115                 /* Because the TURN socket is asynchronous but we are synchronous we need to wait until it is done */
1116                 ast_mutex_lock(&rtp->lock);
1117                 pj_turn_sock_alloc(*turn_sock, &turnaddr, turnport, NULL, &cred, NULL);
1118                 ast_cond_timedwait(&rtp->cond, &rtp->lock, &ts);
1119                 ast_mutex_unlock(&rtp->lock);
1120
1121                 /* If a TURN session was allocated add it as a candidate */
1122                 if (rtp->turn_state == PJ_TURN_STATE_READY) {
1123                         pj_turn_session_info info;
1124
1125                         pj_turn_sock_get_info(*turn_sock, &info);
1126
1127                         if (transport == TRANSPORT_SOCKET_RTP) {
1128                                 transport = TRANSPORT_TURN_RTP;
1129                         } else if (transport == TRANSPORT_SOCKET_RTCP) {
1130                                 transport = TRANSPORT_TURN_RTCP;
1131                         }
1132
1133                         ast_rtp_ice_add_cand(rtp, component, transport, PJ_ICE_CAND_TYPE_RELAYED, 65535, &info.relay_addr, &info.relay_addr,
1134                                              NULL, pj_sockaddr_get_len(&info.relay_addr));
1135                 }
1136         }
1137 }
1138
1139 static int ast_rtp_new(struct ast_rtp_instance *instance,
1140                        struct ast_sched_context *sched, struct ast_sockaddr *addr,
1141                        void *data)
1142 {
1143         struct ast_rtp *rtp = NULL;
1144         int x, startplace;
1145         pj_stun_config stun_config;
1146         pj_str_t ufrag, passwd;
1147
1148         /* Create a new RTP structure to hold all of our data */
1149         if (!(rtp = ast_calloc(1, sizeof(*rtp)))) {
1150                 return -1;
1151         }
1152
1153         /* Initialize synchronization aspects */
1154         ast_mutex_init(&rtp->lock);
1155         ast_cond_init(&rtp->cond, NULL);
1156
1157         /* Set default parameters on the newly created RTP structure */
1158         rtp->ssrc = ast_random();
1159         rtp->seqno = ast_random() & 0xffff;
1160         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
1161         if (strictrtp) {
1162                 rtp_learning_seq_init(rtp, (uint16_t)rtp->seqno);
1163         }
1164
1165         /* Create a new socket for us to listen on and use */
1166         if ((rtp->s =
1167              create_new_socket("RTP",
1168                                ast_sockaddr_is_ipv4(addr) ? AF_INET  :
1169                                ast_sockaddr_is_ipv6(addr) ? AF_INET6 : -1)) < 0) {
1170                 ast_debug(1, "Failed to create a new socket for RTP instance '%p'\n", instance);
1171                 ast_free(rtp);
1172                 return -1;
1173         }
1174
1175         /* Now actually find a free RTP port to use */
1176         x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
1177         x = x & ~1;
1178         startplace = x;
1179
1180         for (;;) {
1181                 ast_sockaddr_set_port(addr, x);
1182                 /* Try to bind, this will tell us whether the port is available or not */
1183                 if (!ast_bind(rtp->s, addr)) {
1184                         ast_debug(1, "Allocated port %d for RTP instance '%p'\n", x, instance);
1185                         ast_rtp_instance_set_local_address(instance, addr);
1186                         break;
1187                 }
1188
1189                 x += 2;
1190                 if (x > rtpend) {
1191                         x = (rtpstart + 1) & ~1;
1192                 }
1193
1194                 /* See if we ran out of ports or if the bind actually failed because of something other than the address being in use */
1195                 if (x == startplace || errno != EADDRINUSE) {
1196                         ast_log(LOG_ERROR, "Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
1197                         close(rtp->s);
1198                         ast_free(rtp);
1199                         return -1;
1200                 }
1201         }
1202
1203         pj_thread_register_check();
1204
1205         pj_stun_config_init(&stun_config, &cachingpool.factory, 0, ioqueue, timerheap);
1206
1207         generate_random_string(rtp->local_ufrag, sizeof(rtp->local_ufrag));
1208         ufrag = pj_str(rtp->local_ufrag);
1209         generate_random_string(rtp->local_passwd, sizeof(rtp->local_passwd));
1210         passwd = pj_str(rtp->local_passwd);
1211
1212         ast_rtp_instance_set_data(instance, rtp);
1213
1214         /* Create an ICE session for ICE negotiation */
1215         if (icesupport && pj_ice_sess_create(&stun_config, NULL, PJ_ICE_SESS_ROLE_UNKNOWN, 2, &ast_rtp_ice_sess_cb, &ufrag, &passwd, &rtp->ice) == PJ_SUCCESS) {
1216                 /* Make this available for the callbacks */
1217                 rtp->ice->user_data = rtp;
1218
1219                 /* Add all of the available candidates to the ICE session */
1220                 rtp_add_candidates_to_ice(instance, rtp, addr, x, COMPONENT_RTP, TRANSPORT_SOCKET_RTP, &ast_rtp_turn_rtp_sock_cb, &rtp->turn_rtp);
1221         }
1222
1223         /* Record any information we may need */
1224         rtp->sched = sched;
1225
1226         return 0;
1227 }
1228
1229 static int ast_rtp_destroy(struct ast_rtp_instance *instance)
1230 {
1231         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1232
1233         /* Destroy the smoother that was smoothing out audio if present */
1234         if (rtp->smoother) {
1235                 ast_smoother_free(rtp->smoother);
1236         }
1237
1238         /* Close our own socket so we no longer get packets */
1239         if (rtp->s > -1) {
1240                 close(rtp->s);
1241         }
1242
1243         /* Destroy RTCP if it was being used */
1244         if (rtp->rtcp) {
1245                 /*
1246                  * It is not possible for there to be an active RTCP scheduler
1247                  * entry at this point since it holds a reference to the
1248                  * RTP instance while it's active.
1249                  */
1250                 close(rtp->rtcp->s);
1251                 ast_free(rtp->rtcp);
1252         }
1253
1254         /* Destroy RED if it was being used */
1255         if (rtp->red) {
1256                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
1257                 ast_free(rtp->red);
1258         }
1259
1260         pj_thread_register_check();
1261
1262         /* Destroy the ICE session if being used */
1263         if (rtp->ice) {
1264                 pj_ice_sess_destroy(rtp->ice);
1265         }
1266
1267         /* Destroy the RTP TURN relay if being used */
1268         if (rtp->turn_rtp) {
1269                 pj_turn_sock_set_user_data(rtp->turn_rtp, NULL);
1270                 pj_turn_sock_destroy(rtp->turn_rtp);
1271         }
1272
1273         /* Destroy the RTCP TURN relay if being used */
1274         if (rtp->turn_rtcp) {
1275                 pj_turn_sock_set_user_data(rtp->turn_rtcp, NULL);
1276                 pj_turn_sock_destroy(rtp->turn_rtcp);
1277         }
1278
1279         /* Destroy any candidates */
1280         if (rtp->local_candidates) {
1281                 ao2_ref(rtp->local_candidates, -1);
1282         }
1283
1284         if (rtp->remote_candidates) {
1285                 ao2_ref(rtp->remote_candidates, -1);
1286         }
1287
1288         /* Destroy synchronization items */
1289         ast_mutex_destroy(&rtp->lock);
1290         ast_cond_destroy(&rtp->cond);
1291
1292         /* Finally destroy ourselves */
1293         ast_free(rtp);
1294
1295         return 0;
1296 }
1297
1298 static int ast_rtp_dtmf_mode_set(struct ast_rtp_instance *instance, enum ast_rtp_dtmf_mode dtmf_mode)
1299 {
1300         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1301         rtp->dtmfmode = dtmf_mode;
1302         return 0;
1303 }
1304
1305 static enum ast_rtp_dtmf_mode ast_rtp_dtmf_mode_get(struct ast_rtp_instance *instance)
1306 {
1307         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1308         return rtp->dtmfmode;
1309 }
1310
1311 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
1312 {
1313         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1314         struct ast_sockaddr remote_address = { {0,} };
1315         int hdrlen = 12, res = 0, i = 0, payload = 101;
1316         char data[256];
1317         unsigned int *rtpheader = (unsigned int*)data;
1318
1319         ast_rtp_instance_get_remote_address(instance, &remote_address);
1320
1321         /* If we have no remote address information bail out now */
1322         if (ast_sockaddr_isnull(&remote_address)) {
1323                 return -1;
1324         }
1325
1326         /* Convert given digit into what we want to transmit */
1327         if ((digit <= '9') && (digit >= '0')) {
1328                 digit -= '0';
1329         } else if (digit == '*') {
1330                 digit = 10;
1331         } else if (digit == '#') {
1332                 digit = 11;
1333         } else if ((digit >= 'A') && (digit <= 'D')) {
1334                 digit = digit - 'A' + 12;
1335         } else if ((digit >= 'a') && (digit <= 'd')) {
1336                 digit = digit - 'a' + 12;
1337         } else {
1338                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1339                 return -1;
1340         }
1341
1342         /* Grab the payload that they expect the RFC2833 packet to be received in */
1343         payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 0, NULL, AST_RTP_DTMF);
1344
1345         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1346         rtp->send_duration = 160;
1347         rtp->lastdigitts = rtp->lastts + rtp->send_duration;
1348
1349         /* Create the actual packet that we will be sending */
1350         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1351         rtpheader[1] = htonl(rtp->lastdigitts);
1352         rtpheader[2] = htonl(rtp->ssrc);
1353
1354         /* Actually send the packet */
1355         for (i = 0; i < 2; i++) {
1356                 int ice;
1357
1358                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
1359                 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
1360                 if (res < 0) {
1361                         ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
1362                                 ast_sockaddr_stringify(&remote_address),
1363                                 strerror(errno));
1364                 }
1365                 update_address_with_ice_candidate(rtp, COMPONENT_RTP, &remote_address);
1366                 if (rtp_debug_test_addr(&remote_address)) {
1367                         ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1368                                     ast_sockaddr_stringify(&remote_address),
1369                                     ice ? " (via ICE)" : "",
1370                                     payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1371                 }
1372                 rtp->seqno++;
1373                 rtp->send_duration += 160;
1374                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1375         }
1376
1377         /* Record that we are in the process of sending a digit and information needed to continue doing so */
1378         rtp->sending_digit = 1;
1379         rtp->send_digit = digit;
1380         rtp->send_payload = payload;
1381
1382         return 0;
1383 }
1384
1385 static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
1386 {
1387         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1388         struct ast_sockaddr remote_address = { {0,} };
1389         int hdrlen = 12, res = 0;
1390         char data[256];
1391         unsigned int *rtpheader = (unsigned int*)data;
1392         int ice;
1393
1394         ast_rtp_instance_get_remote_address(instance, &remote_address);
1395
1396         /* Make sure we know where the other side is so we can send them the packet */
1397         if (ast_sockaddr_isnull(&remote_address)) {
1398                 return -1;
1399         }
1400
1401         /* Actually create the packet we will be sending */
1402         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
1403         rtpheader[1] = htonl(rtp->lastdigitts);
1404         rtpheader[2] = htonl(rtp->ssrc);
1405         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
1406
1407         /* Boom, send it on out */
1408         res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
1409         if (res < 0) {
1410                 ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
1411                         ast_sockaddr_stringify(&remote_address),
1412                         strerror(errno));
1413         }
1414
1415         update_address_with_ice_candidate(rtp, COMPONENT_RTP, &remote_address);
1416
1417         if (rtp_debug_test_addr(&remote_address)) {
1418                 ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1419                             ast_sockaddr_stringify(&remote_address),
1420                             ice ? " (via ICE)" : "",
1421                             rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1422         }
1423
1424         /* And now we increment some values for the next time we swing by */
1425         rtp->seqno++;
1426         rtp->send_duration += 160;
1427
1428         return 0;
1429 }
1430
1431 static int ast_rtp_dtmf_end_with_duration(struct ast_rtp_instance *instance, char digit, unsigned int duration)
1432 {
1433         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1434         struct ast_sockaddr remote_address = { {0,} };
1435         int hdrlen = 12, res = 0, i = 0;
1436         char data[256];
1437         unsigned int *rtpheader = (unsigned int*)data;
1438         unsigned int measured_samples;
1439
1440         ast_rtp_instance_get_remote_address(instance, &remote_address);
1441
1442         /* Make sure we know where the remote side is so we can send them the packet we construct */
1443         if (ast_sockaddr_isnull(&remote_address)) {
1444                 return -1;
1445         }
1446
1447         /* Convert the given digit to the one we are going to send */
1448         if ((digit <= '9') && (digit >= '0')) {
1449                 digit -= '0';
1450         } else if (digit == '*') {
1451                 digit = 10;
1452         } else if (digit == '#') {
1453                 digit = 11;
1454         } else if ((digit >= 'A') && (digit <= 'D')) {
1455                 digit = digit - 'A' + 12;
1456         } else if ((digit >= 'a') && (digit <= 'd')) {
1457                 digit = digit - 'a' + 12;
1458         } else {
1459                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1460                 return -1;
1461         }
1462
1463         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1464
1465         if (duration > 0 && (measured_samples = duration * rtp_get_rate(&rtp->f.subclass.format) / 1000) > rtp->send_duration) {
1466                 ast_debug(2, "Adjusting final end duration from %u to %u\n", rtp->send_duration, measured_samples);
1467                 rtp->send_duration = measured_samples;
1468         }
1469
1470         /* Construct the packet we are going to send */
1471         rtpheader[1] = htonl(rtp->lastdigitts);
1472         rtpheader[2] = htonl(rtp->ssrc);
1473         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
1474         rtpheader[3] |= htonl((1 << 23));
1475
1476         /* Send it 3 times, that's the magical number */
1477         for (i = 0; i < 3; i++) {
1478                 int ice;
1479
1480                 rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
1481
1482                 res = rtp_sendto(instance, (void *) rtpheader, hdrlen + 4, 0, &remote_address, &ice);
1483
1484                 if (res < 0) {
1485                         ast_log(LOG_ERROR, "RTP Transmission error to %s: %s\n",
1486                                 ast_sockaddr_stringify(&remote_address),
1487                                 strerror(errno));
1488                 }
1489
1490                 update_address_with_ice_candidate(rtp, COMPONENT_RTP, &remote_address);
1491
1492                 if (rtp_debug_test_addr(&remote_address)) {
1493                         ast_verbose("Sent RTP DTMF packet to %s%s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1494                                     ast_sockaddr_stringify(&remote_address),
1495                                     ice ? " (via ICE)" : "",
1496                                     rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1497                 }
1498
1499                 rtp->seqno++;
1500         }
1501
1502         /* Oh and we can't forget to turn off the stuff that says we are sending DTMF */
1503         rtp->lastts += rtp->send_duration;
1504         rtp->sending_digit = 0;
1505         rtp->send_digit = 0;
1506
1507         return 0;
1508 }
1509
1510 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
1511 {
1512         return ast_rtp_dtmf_end_with_duration(instance, digit, 0);
1513 }
1514
1515 static void ast_rtp_update_source(struct ast_rtp_instance *instance)
1516 {
1517         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1518
1519         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
1520         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
1521         ast_debug(3, "Setting the marker bit due to a source update\n");
1522
1523         return;
1524 }
1525
1526 static void ast_rtp_change_source(struct ast_rtp_instance *instance)
1527 {
1528         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1529         struct ast_srtp *srtp = ast_rtp_instance_get_srtp(instance);
1530         unsigned int ssrc = ast_random();
1531
1532         if (!rtp->lastts) {
1533                 ast_debug(3, "Not changing SSRC since we haven't sent any RTP yet\n");
1534                 return;
1535         }
1536
1537         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
1538         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
1539
1540         ast_debug(3, "Changing ssrc from %u to %u due to a source change\n", rtp->ssrc, ssrc);
1541
1542         if (srtp) {
1543                 ast_debug(3, "Changing ssrc for SRTP from %u to %u\n", rtp->ssrc, ssrc);
1544                 res_srtp->change_source(srtp, rtp->ssrc, ssrc);
1545         }
1546
1547         rtp->ssrc = ssrc;
1548
1549         return;
1550 }
1551
1552 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1553 {
1554         struct timeval t;
1555         long ms;
1556
1557         if (ast_tvzero(rtp->txcore)) {
1558                 rtp->txcore = ast_tvnow();
1559                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1560         }
1561
1562         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1563         if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
1564                 ms = 0;
1565         }
1566         rtp->txcore = t;
1567
1568         return (unsigned int) ms;
1569 }
1570
1571 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
1572 {
1573         unsigned int sec, usec, frac;
1574         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
1575         usec = tv.tv_usec;
1576         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
1577         *msw = sec;
1578         *lsw = frac;
1579 }
1580
1581 /*! \brief Send RTCP recipient's report */
1582 static int ast_rtcp_write_rr(struct ast_rtp_instance *instance)
1583 {
1584         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1585         int res;
1586         int len = 32;
1587         unsigned int lost;
1588         unsigned int extended;
1589         unsigned int expected;
1590         unsigned int expected_interval;
1591         unsigned int received_interval;
1592         int lost_interval;
1593         struct timeval now;
1594         unsigned int *rtcpheader;
1595         char bdata[1024];
1596         struct timeval dlsr;
1597         int fraction;
1598         int rate = rtp_get_rate(&rtp->f.subclass.format);
1599         int ice;
1600         double rxlost_current;
1601         struct ast_sockaddr remote_address = { {0,} };
1602
1603         if (!rtp || !rtp->rtcp)
1604                 return 0;
1605
1606         if (ast_sockaddr_isnull(&rtp->rtcp->them)) {
1607                 /*
1608                  * RTCP was stopped.
1609                  */
1610                 return 0;
1611         }
1612
1613         extended = rtp->cycles + rtp->lastrxseqno;
1614         expected = extended - rtp->seedrxseqno + 1;
1615         lost = expected - rtp->rxcount;
1616         expected_interval = expected - rtp->rtcp->expected_prior;
1617         rtp->rtcp->expected_prior = expected;
1618         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
1619         rtp->rtcp->received_prior = rtp->rxcount;
1620         lost_interval = expected_interval - received_interval;
1621
1622         if (lost_interval <= 0)
1623                 rtp->rtcp->rxlost = 0;
1624         else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
1625         if (rtp->rtcp->rxlost_count == 0)
1626                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
1627         if (lost_interval < rtp->rtcp->minrxlost)
1628                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
1629         if (lost_interval > rtp->rtcp->maxrxlost)
1630                 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
1631
1632         rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
1633         rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
1634         rtp->rtcp->normdev_rxlost = rxlost_current;
1635         rtp->rtcp->rxlost_count++;
1636
1637         if (expected_interval == 0 || lost_interval <= 0)
1638                 fraction = 0;
1639         else
1640                 fraction = (lost_interval << 8) / expected_interval;
1641         gettimeofday(&now, NULL);
1642         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
1643         rtcpheader = (unsigned int *)bdata;
1644         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
1645         rtcpheader[1] = htonl(rtp->ssrc);
1646         rtcpheader[2] = htonl(rtp->themssrc);
1647         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
1648         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
1649         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * rate));
1650         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
1651         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
1652
1653         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
1654           it can change mid call, and SDES can't) */
1655         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
1656         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
1657         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
1658         len += 12;
1659
1660         ast_sockaddr_copy(&remote_address, &rtp->rtcp->them);
1661
1662         res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &remote_address, &ice);
1663
1664         if (res < 0) {
1665                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
1666                 return 0;
1667         }
1668
1669         rtp->rtcp->rr_count++;
1670
1671         update_address_with_ice_candidate(rtp, COMPONENT_RTCP, &remote_address);
1672
1673         if (rtcp_debug_test_addr(&remote_address)) {
1674                 ast_verbose("\n* Sending RTCP RR to %s%s\n"
1675                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
1676                         "  IA jitter: %.4f\n"
1677                         "  Their last SR: %u\n"
1678                             "  DLSR: %4.4f (sec)\n\n",
1679                             ast_sockaddr_stringify(&remote_address),
1680                             ice ? " (via ICE)" : "",
1681                             rtp->ssrc, rtp->themssrc, fraction, lost,
1682                             rtp->rxjitter,
1683                             rtp->rtcp->themrxlsr,
1684                             (double)(ntohl(rtcpheader[7])/65536.0));
1685         }
1686
1687         return res;
1688 }
1689
1690 /*! \brief Send RTCP sender's report */
1691 static int ast_rtcp_write_sr(struct ast_rtp_instance *instance)
1692 {
1693         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1694         int res;
1695         int len = 0;
1696         struct timeval now;
1697         unsigned int now_lsw;
1698         unsigned int now_msw;
1699         unsigned int *rtcpheader;
1700         unsigned int lost;
1701         unsigned int extended;
1702         unsigned int expected;
1703         unsigned int expected_interval;
1704         unsigned int received_interval;
1705         int lost_interval;
1706         int fraction;
1707         struct timeval dlsr;
1708         char bdata[512];
1709         int rate = rtp_get_rate(&rtp->f.subclass.format);
1710         int ice;
1711         struct ast_sockaddr remote_address = { {0,} };
1712
1713         if (!rtp || !rtp->rtcp)
1714                 return 0;
1715
1716         if (ast_sockaddr_isnull(&rtp->rtcp->them)) {  /* This'll stop rtcp for this rtp session */
1717                 /*
1718                  * RTCP was stopped.
1719                  */
1720                 return 0;
1721         }
1722
1723         gettimeofday(&now, NULL);
1724         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
1725         rtcpheader = (unsigned int *)bdata;
1726         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
1727         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
1728         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
1729         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
1730         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
1731         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
1732         len += 28;
1733
1734         extended = rtp->cycles + rtp->lastrxseqno;
1735         expected = extended - rtp->seedrxseqno + 1;
1736         if (rtp->rxcount > expected)
1737                 expected += rtp->rxcount - expected;
1738         lost = expected - rtp->rxcount;
1739         expected_interval = expected - rtp->rtcp->expected_prior;
1740         rtp->rtcp->expected_prior = expected;
1741         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
1742         rtp->rtcp->received_prior = rtp->rxcount;
1743         lost_interval = expected_interval - received_interval;
1744         if (expected_interval == 0 || lost_interval <= 0)
1745                 fraction = 0;
1746         else
1747                 fraction = (lost_interval << 8) / expected_interval;
1748         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
1749         rtcpheader[7] = htonl(rtp->themssrc);
1750         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
1751         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
1752         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * rate));
1753         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
1754         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
1755         len += 24;
1756
1757         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
1758
1759         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
1760         /* it can change mid call, and SDES can't) */
1761         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
1762         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
1763         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
1764         len += 12;
1765
1766         ast_sockaddr_copy(&remote_address, &rtp->rtcp->them);
1767
1768         res = rtcp_sendto(instance, (unsigned int *)rtcpheader, len, 0, &remote_address, &ice);
1769         if (res < 0) {
1770                 ast_log(LOG_ERROR, "RTCP SR transmission error to %s, rtcp halted %s\n",
1771                         ast_sockaddr_stringify(&rtp->rtcp->them),
1772                         strerror(errno));
1773                 return 0;
1774         }
1775
1776         /* FIXME Don't need to get a new one */
1777         gettimeofday(&rtp->rtcp->txlsr, NULL);
1778         rtp->rtcp->sr_count++;
1779
1780         rtp->rtcp->lastsrtxcount = rtp->txcount;
1781
1782         update_address_with_ice_candidate(rtp, COMPONENT_RTCP, &remote_address);
1783
1784         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
1785                 ast_verbose("* Sent RTCP SR to %s%s\n", ast_sockaddr_stringify(&remote_address), ice ? " (via ICE)" : "");
1786                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
1787                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
1788                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
1789                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
1790                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
1791                 ast_verbose("  Report block:\n");
1792                 ast_verbose("  Fraction lost: %u\n", fraction);
1793                 ast_verbose("  Cumulative loss: %u\n", lost);
1794                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
1795                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
1796                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
1797         }
1798         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To: %s\r\n"
1799                                             "OurSSRC: %u\r\n"
1800                                             "SentNTP: %u.%010u\r\n"
1801                                             "SentRTP: %u\r\n"
1802                                             "SentPackets: %u\r\n"
1803                                             "SentOctets: %u\r\n"
1804                                             "ReportBlock:\r\n"
1805                                             "FractionLost: %u\r\n"
1806                                             "CumulativeLoss: %u\r\n"
1807                                             "IAJitter: %.4f\r\n"
1808                                             "TheirLastSR: %u\r\n"
1809                       "DLSR: %4.4f (sec)\r\n",
1810                       ast_sockaddr_stringify(&remote_address),
1811                       rtp->ssrc,
1812                       (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
1813                       rtp->lastts,
1814                       rtp->txcount,
1815                       rtp->txoctetcount,
1816                       fraction,
1817                       lost,
1818                       rtp->rxjitter,
1819                       rtp->rtcp->themrxlsr,
1820                       (double)(ntohl(rtcpheader[12])/65536.0));
1821         return res;
1822 }
1823
1824 /*! \brief Write and RTCP packet to the far end
1825  * \note Decide if we are going to send an SR (with Reception Block) or RR
1826  * RR is sent if we have not sent any rtp packets in the previous interval */
1827 static int ast_rtcp_write(const void *data)
1828 {
1829         struct ast_rtp_instance *instance = (struct ast_rtp_instance *) data;
1830         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1831         int res;
1832
1833         if (!rtp || !rtp->rtcp || rtp->rtcp->schedid == -1) {
1834                 ao2_ref(instance, -1);
1835                 return 0;
1836         }
1837
1838         if (rtp->txcount > rtp->rtcp->lastsrtxcount) {
1839                 res = ast_rtcp_write_sr(instance);
1840         } else {
1841                 res = ast_rtcp_write_rr(instance);
1842         }
1843
1844         if (!res) {
1845                 /* 
1846                  * Not being rescheduled.
1847                  */
1848                 ao2_ref(instance, -1);
1849                 rtp->rtcp->schedid = -1;
1850         }
1851
1852         return res;
1853 }
1854
1855 static int ast_rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
1856 {
1857         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1858         int pred, mark = 0;
1859         unsigned int ms = calc_txstamp(rtp, &frame->delivery);
1860         struct ast_sockaddr remote_address = { {0,} };
1861         int rate = rtp_get_rate(&frame->subclass.format) / 1000;
1862
1863         if (frame->subclass.format.id == AST_FORMAT_G722) {
1864                 frame->samples /= 2;
1865         }
1866
1867         if (rtp->sending_digit) {
1868                 return 0;
1869         }
1870
1871         if (frame->frametype == AST_FRAME_VOICE) {
1872                 pred = rtp->lastts + frame->samples;
1873
1874                 /* Re-calculate last TS */
1875                 rtp->lastts = rtp->lastts + ms * rate;
1876                 if (ast_tvzero(frame->delivery)) {
1877                         /* If this isn't an absolute delivery time, Check if it is close to our prediction,
1878                            and if so, go with our prediction */
1879                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) {
1880                                 rtp->lastts = pred;
1881                         } else {
1882                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1883                                 mark = 1;
1884                         }
1885                 }
1886         } else if (frame->frametype == AST_FRAME_VIDEO) {
1887                 mark = ast_format_get_video_mark(&frame->subclass.format);
1888                 pred = rtp->lastovidtimestamp + frame->samples;
1889                 /* Re-calculate last TS */
1890                 rtp->lastts = rtp->lastts + ms * 90;
1891                 /* If it's close to our prediction, go for it */
1892                 if (ast_tvzero(frame->delivery)) {
1893                         if (abs(rtp->lastts - pred) < 7200) {
1894                                 rtp->lastts = pred;
1895                                 rtp->lastovidtimestamp += frame->samples;
1896                         } else {
1897                                 ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, frame->samples);
1898                                 rtp->lastovidtimestamp = rtp->lastts;
1899                         }
1900                 }
1901         } else {
1902                 pred = rtp->lastotexttimestamp + frame->samples;
1903                 /* Re-calculate last TS */
1904                 rtp->lastts = rtp->lastts + ms;
1905                 /* If it's close to our prediction, go for it */
1906                 if (ast_tvzero(frame->delivery)) {
1907                         if (abs(rtp->lastts - pred) < 7200) {
1908                                 rtp->lastts = pred;
1909                                 rtp->lastotexttimestamp += frame->samples;
1910                         } else {
1911                                 ast_debug(3, "Difference is %d, ms is %d, pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, rtp->lastts, pred, frame->samples);
1912                                 rtp->lastotexttimestamp = rtp->lastts;
1913                         }
1914                 }
1915         }
1916
1917         /* If we have been explicitly told to set the marker bit then do so */
1918         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1919                 mark = 1;
1920                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1921         }
1922
1923         /* If the timestamp for non-digt packets has moved beyond the timestamp for digits, update the digit timestamp */
1924         if (rtp->lastts > rtp->lastdigitts) {
1925                 rtp->lastdigitts = rtp->lastts;
1926         }
1927
1928         if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
1929                 rtp->lastts = frame->ts * rate;
1930         }
1931
1932         ast_rtp_instance_get_remote_address(instance, &remote_address);
1933
1934         /* If we know the remote address construct a packet and send it out */
1935         if (!ast_sockaddr_isnull(&remote_address)) {
1936                 int hdrlen = 12, res, ice;
1937                 unsigned char *rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);
1938
1939                 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1940                 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1941                 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
1942
1943                 if ((res = rtp_sendto(instance, (void *)rtpheader, frame->datalen + hdrlen, 0, &remote_address, &ice)) < 0) {
1944                         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))) {
1945                                 ast_debug(1, "RTP Transmission error of packet %d to %s: %s\n",
1946                                           rtp->seqno,
1947                                           ast_sockaddr_stringify(&remote_address),
1948                                           strerror(errno));
1949                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
1950                                 /* Only give this error message once if we are not RTP debugging */
1951                                 if (rtpdebug)
1952                                         ast_debug(0, "RTP NAT: Can't write RTP to private address %s, waiting for other end to send audio...\n",
1953                                                   ast_sockaddr_stringify(&remote_address));
1954                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1955                         }
1956                 } else {
1957                         rtp->txcount++;
1958                         rtp->txoctetcount += (res - hdrlen);
1959
1960                         if (rtp->rtcp && rtp->rtcp->schedid < 1) {
1961                                 ast_debug(1, "Starting RTCP transmission on RTP instance '%p'\n", instance);
1962                                 ao2_ref(instance, +1);
1963                                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
1964                                 if (rtp->rtcp->schedid < 0) {
1965                                         ao2_ref(instance, -1);
1966                                         ast_log(LOG_WARNING, "scheduling RTCP transmission failed.\n");
1967                                 }
1968                         }
1969                 }
1970
1971                 update_address_with_ice_candidate(rtp, COMPONENT_RTP, &remote_address);
1972
1973                 if (rtp_debug_test_addr(&remote_address)) {
1974                         ast_verbose("Sent RTP packet to      %s%s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1975                                     ast_sockaddr_stringify(&remote_address),
1976                                     ice ? " (via ICE)" : "",
1977                                     codec, rtp->seqno, rtp->lastts, res - hdrlen);
1978                 }
1979         }
1980
1981         rtp->seqno++;
1982
1983         return 0;
1984 }
1985
1986 static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
1987         unsigned char *data = red->t140red.data.ptr;
1988         int len = 0;
1989         int i;
1990
1991         /* replace most aged generation */
1992         if (red->len[0]) {
1993                 for (i = 1; i < red->num_gen+1; i++)
1994                         len += red->len[i];
1995
1996                 memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len);
1997         }
1998
1999         /* Store length of each generation and primary data length*/
2000         for (i = 0; i < red->num_gen; i++)
2001                 red->len[i] = red->len[i+1];
2002         red->len[i] = red->t140.datalen;
2003
2004         /* write each generation length in red header */
2005         len = red->hdrlen;
2006         for (i = 0; i < red->num_gen; i++)
2007                 len += data[i*4+3] = red->len[i];
2008
2009         /* add primary data to buffer */
2010         memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
2011         red->t140red.datalen = len + red->t140.datalen;
2012
2013         /* no primary data and no generations to send */
2014         if (len == red->hdrlen && !red->t140.datalen)
2015                 return NULL;
2016
2017         /* reset t.140 buffer */
2018         red->t140.datalen = 0;
2019
2020         return &red->t140red;
2021 }
2022
2023 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
2024 {
2025         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2026         struct ast_sockaddr remote_address = { {0,} };
2027         struct ast_format subclass;
2028         int codec;
2029
2030         ast_rtp_instance_get_remote_address(instance, &remote_address);
2031
2032         /* If we don't actually know the remote address don't even bother doing anything */
2033         if (ast_sockaddr_isnull(&remote_address)) {
2034                 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
2035                 return 0;
2036         }
2037
2038         /* If there is no data length we can't very well send the packet */
2039         if (!frame->datalen) {
2040                 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
2041                 return 0;
2042         }
2043
2044         /* If the packet is not one our RTP stack supports bail out */
2045         if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
2046                 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
2047                 return -1;
2048         }
2049
2050         if (rtp->red) {
2051                 /* return 0; */
2052                 /* no primary data or generations to send */
2053                 if ((frame = red_t140_to_red(rtp->red)) == NULL)
2054                         return 0;
2055         }
2056
2057         /* Grab the subclass and look up the payload we are going to use */
2058         ast_format_copy(&subclass, &frame->subclass.format);
2059         if ((codec = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 1, &subclass, 0)) < 0) {
2060                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(&frame->subclass.format));
2061                 return -1;
2062         }
2063
2064         /* Oh dear, if the format changed we will have to set up a new smoother */
2065         if (ast_format_cmp(&rtp->lasttxformat, &subclass) == AST_FORMAT_CMP_NOT_EQUAL) {
2066                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(&rtp->lasttxformat), ast_getformatname(&subclass));
2067                 rtp->lasttxformat = subclass;
2068                 ast_format_copy(&rtp->lasttxformat, &subclass);
2069                 if (rtp->smoother) {
2070                         ast_smoother_free(rtp->smoother);
2071                         rtp->smoother = NULL;
2072                 }
2073         }
2074
2075         /* If no smoother is present see if we have to set one up */
2076         if (!rtp->smoother) {
2077                 struct ast_format_list fmt = ast_codec_pref_getsize(&ast_rtp_instance_get_codecs(instance)->pref, &subclass);
2078
2079                 switch (subclass.id) {
2080                 case AST_FORMAT_SPEEX:
2081                 case AST_FORMAT_SPEEX16:
2082                 case AST_FORMAT_SPEEX32:
2083                 case AST_FORMAT_SILK:
2084                 case AST_FORMAT_CELT:
2085                 case AST_FORMAT_G723_1:
2086                 case AST_FORMAT_SIREN7:
2087                 case AST_FORMAT_SIREN14:
2088                 case AST_FORMAT_G719:
2089                         /* these are all frame-based codecs and cannot be safely run through
2090                            a smoother */
2091                         break;
2092                 default:
2093                         if (fmt.inc_ms) {
2094                                 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2095                                         ast_log(LOG_WARNING, "Unable to create smoother: format %s ms: %d len: %d\n", ast_getformatname(&subclass), fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2096                                         return -1;
2097                                 }
2098                                 if (fmt.flags) {
2099                                         ast_smoother_set_flags(rtp->smoother, fmt.flags);
2100                                 }
2101                                 ast_debug(1, "Created smoother: format: %s ms: %d len: %d\n", ast_getformatname(&subclass), fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2102                         }
2103                 }
2104         }
2105
2106         /* Feed audio frames into the actual function that will create a frame and send it */
2107         if (rtp->smoother) {
2108                 struct ast_frame *f;
2109
2110                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2111                         ast_smoother_feed_be(rtp->smoother, frame);
2112                 } else {
2113                         ast_smoother_feed(rtp->smoother, frame);
2114                 }
2115
2116                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
2117                                 ast_rtp_raw_write(instance, f, codec);
2118                 }
2119         } else {
2120                 int hdrlen = 12;
2121                 struct ast_frame *f = NULL;
2122
2123                 if (frame->offset < hdrlen) {
2124                         f = ast_frdup(frame);
2125                 } else {
2126                         f = frame;
2127                 }
2128                 if (f->data.ptr) {
2129                         ast_rtp_raw_write(instance, f, codec);
2130                 }
2131                 if (f != frame) {
2132                         ast_frfree(f);
2133                 }
2134
2135         }
2136
2137         return 0;
2138 }
2139
2140 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
2141 {
2142         struct timeval now;
2143         struct timeval tmp;
2144         double transit;
2145         double current_time;
2146         double d;
2147         double dtv;
2148         double prog;
2149         int rate = rtp_get_rate(&rtp->f.subclass.format);
2150
2151         double normdev_rxjitter_current;
2152         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
2153                 gettimeofday(&rtp->rxcore, NULL);
2154                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
2155                 /* map timestamp to a real time */
2156                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
2157                 tmp = ast_samp2tv(timestamp, rate);
2158                 rtp->rxcore = ast_tvsub(rtp->rxcore, tmp);
2159                 /* Round to 0.1ms for nice, pretty timestamps */
2160                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
2161         }
2162
2163         gettimeofday(&now,NULL);
2164         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
2165         tmp = ast_samp2tv(timestamp, rate);
2166         *tv = ast_tvadd(rtp->rxcore, tmp);
2167
2168         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
2169         dtv = (double)rtp->drxcore + (double)(prog);
2170         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
2171         transit = current_time - dtv;
2172         d = transit - rtp->rxtransit;
2173         rtp->rxtransit = transit;
2174         if (d<0)
2175                 d=-d;
2176         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
2177
2178         if (rtp->rtcp) {
2179                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
2180                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
2181                 if (rtp->rtcp->rxjitter_count == 1)
2182                         rtp->rtcp->minrxjitter = rtp->rxjitter;
2183                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
2184                         rtp->rtcp->minrxjitter = rtp->rxjitter;
2185
2186                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
2187                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
2188
2189                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
2190                 rtp->rtcp->rxjitter_count++;
2191         }
2192 }
2193
2194 static struct ast_frame *create_dtmf_frame(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
2195 {
2196         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2197         struct ast_sockaddr remote_address = { {0,} };
2198
2199         ast_rtp_instance_get_remote_address(instance, &remote_address);
2200
2201         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
2202                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n",
2203                           ast_sockaddr_stringify(&remote_address));
2204                 rtp->resp = 0;
2205                 rtp->dtmfsamples = 0;
2206                 return &ast_null_frame;
2207         }
2208         ast_debug(1, "Creating %s DTMF Frame: %d (%c), at %s\n",
2209                 type == AST_FRAME_DTMF_END ? "END" : "BEGIN",
2210                 rtp->resp, rtp->resp,
2211                 ast_sockaddr_stringify(&remote_address));
2212         if (rtp->resp == 'X') {
2213                 rtp->f.frametype = AST_FRAME_CONTROL;
2214                 rtp->f.subclass.integer = AST_CONTROL_FLASH;
2215         } else {
2216                 rtp->f.frametype = type;
2217                 rtp->f.subclass.integer = rtp->resp;
2218         }
2219         rtp->f.datalen = 0;
2220         rtp->f.samples = 0;
2221         rtp->f.mallocd = 0;
2222         rtp->f.src = "RTP";
2223         AST_LIST_NEXT(&rtp->f, frame_list) = NULL;
2224
2225         return &rtp->f;
2226 }
2227
2228 static void process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark, struct frame_list *frames)
2229 {
2230         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2231         struct ast_sockaddr remote_address = { {0,} };
2232         unsigned int event, event_end, samples;
2233         char resp = 0;
2234         struct ast_frame *f = NULL;
2235
2236         ast_rtp_instance_get_remote_address(instance, &remote_address);
2237
2238         /* Figure out event, event end, and samples */
2239         event = ntohl(*((unsigned int *)(data)));
2240         event >>= 24;
2241         event_end = ntohl(*((unsigned int *)(data)));
2242         event_end <<= 8;
2243         event_end >>= 24;
2244         samples = ntohl(*((unsigned int *)(data)));
2245         samples &= 0xFFFF;
2246
2247         if (rtp_debug_test_addr(&remote_address)) {
2248                 ast_verbose("Got  RTP RFC2833 from   %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n",
2249                             ast_sockaddr_stringify(&remote_address),
2250                             payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
2251         }
2252
2253         /* Print out debug if turned on */
2254         if (rtpdebug)
2255                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
2256
2257         /* Figure out what digit was pressed */
2258         if (event < 10) {
2259                 resp = '0' + event;
2260         } else if (event < 11) {
2261                 resp = '*';
2262         } else if (event < 12) {
2263                 resp = '#';
2264         } else if (event < 16) {
2265                 resp = 'A' + (event - 12);
2266         } else if (event < 17) {        /* Event 16: Hook flash */
2267                 resp = 'X';
2268         } else {
2269                 /* Not a supported event */
2270                 ast_debug(1, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
2271                 return;
2272         }
2273
2274         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
2275                 if ((rtp->last_end_timestamp != timestamp) || (rtp->resp && rtp->resp != resp)) {
2276                         rtp->resp = resp;
2277                         rtp->dtmf_timeout = 0;
2278                         f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)));
2279                         f->len = 0;
2280                         rtp->last_end_timestamp = timestamp;
2281                         AST_LIST_INSERT_TAIL(frames, f, frame_list);
2282                 }
2283         } else {
2284                 /*  The duration parameter measures the complete
2285                     duration of the event (from the beginning) - RFC2833.
2286                     Account for the fact that duration is only 16 bits long
2287                     (about 8 seconds at 8000 Hz) and can wrap is digit
2288                     is hold for too long. */
2289                 unsigned int new_duration = rtp->dtmf_duration;
2290                 unsigned int last_duration = new_duration & 0xFFFF;
2291
2292                 if (last_duration > 64000 && samples < last_duration) {
2293                         new_duration += 0xFFFF + 1;
2294                 }
2295                 new_duration = (new_duration & ~0xFFFF) | samples;
2296
2297                 if (event_end & 0x80) {
2298                         /* End event */
2299                         if ((rtp->last_seqno != seqno) && (timestamp > rtp->last_end_timestamp)) {
2300                                 rtp->last_end_timestamp = timestamp;
2301                                 rtp->dtmf_duration = new_duration;
2302                                 rtp->resp = resp;
2303                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
2304                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(&f->subclass.format)), ast_tv(0, 0));
2305                                 rtp->resp = 0;
2306                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
2307                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
2308                         } else if (rtpdebug) {
2309                                 ast_debug(1, "Dropping duplicate or out of order DTMF END frame (seqno: %d, ts %d, digit %c)\n",
2310                                         seqno, timestamp, resp);
2311                         }
2312                 } else {
2313                         /* Begin/continuation */
2314
2315                         /* The second portion of the seqno check is to not mistakenly
2316                          * stop accepting DTMF if the seqno rolls over beyond
2317                          * 65535.
2318                          */
2319                         if ((rtp->last_seqno > seqno && rtp->last_seqno - seqno < 50)
2320                                 || timestamp <= rtp->last_end_timestamp) {
2321                                 /* Out of order frame. Processing this can cause us to
2322                                  * improperly duplicate incoming DTMF, so just drop
2323                                  * this.
2324                                  */
2325                                 if (rtpdebug) {
2326                                         ast_debug(1, "Dropping out of order DTMF frame (seqno %d, ts %d, digit %c)\n",
2327                                                 seqno, timestamp, resp);
2328                                 }
2329                                 return;
2330                         }
2331
2332                         if (rtp->resp && rtp->resp != resp) {
2333                                 /* Another digit already began. End it */
2334                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
2335                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(&f->subclass.format)), ast_tv(0, 0));
2336                                 rtp->resp = 0;
2337                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
2338                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
2339                         }
2340
2341                         if (rtp->resp) {
2342                                 /* Digit continues */
2343                                 rtp->dtmf_duration = new_duration;
2344                         } else {
2345                                 /* New digit began */
2346                                 rtp->resp = resp;
2347                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0));
2348                                 rtp->dtmf_duration = samples;
2349                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
2350                         }
2351
2352                         rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
2353                 }
2354
2355                 rtp->last_seqno = seqno;
2356         }
2357
2358         rtp->dtmfsamples = samples;
2359
2360         return;
2361 }
2362
2363 static struct ast_frame *process_dtmf_cisco(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark)
2364 {
2365         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2366         unsigned int event, flags, power;
2367         char resp = 0;
2368         unsigned char seq;
2369         struct ast_frame *f = NULL;
2370
2371         if (len < 4) {
2372                 return NULL;
2373         }
2374
2375         /*      The format of Cisco RTP DTMF packet looks like next:
2376                 +0                              - sequence number of DTMF RTP packet (begins from 1,
2377                                                   wrapped to 0)
2378                 +1                              - set of flags
2379                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
2380                                                   or repeated digit without audio???
2381                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
2382                                                   then falls to 0 at its end)
2383                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
2384                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
2385                 by each new packet and thus provides some redudancy.
2386
2387                 Sample of Cisco RTP DTMF packet is (all data in hex):
2388                         19 07 00 02 12 02 20 02
2389                 showing end of DTMF digit '2'.
2390
2391                 The packets
2392                         27 07 00 02 0A 02 20 02
2393                         28 06 20 02 00 02 0A 02
2394                 shows begin of new digit '2' with very short pause (20 ms) after
2395                 previous digit '2'. Bit +1.0 flips at begin of new digit.
2396
2397                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
2398                 so its uses the same sequencing and timestamping rules as replaced
2399                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
2400                 on audio framing parameters. Marker bit isn't used within stream of
2401                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
2402                 are not sequential at borders between DTMF and audio streams,
2403         */
2404
2405         seq = data[0];
2406         flags = data[1];
2407         power = data[2];
2408         event = data[3] & 0x1f;
2409
2410         if (rtpdebug)
2411                 ast_debug(0, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
2412         if (event < 10) {
2413                 resp = '0' + event;
2414         } else if (event < 11) {
2415                 resp = '*';
2416         } else if (event < 12) {
2417                 resp = '#';
2418         } else if (event < 16) {
2419                 resp = 'A' + (event - 12);
2420         } else if (event < 17) {
2421                 resp = 'X';
2422         }
2423         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
2424                 rtp->resp = resp;
2425                 /* Why we should care on DTMF compensation at reception? */
2426                 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
2427                         f = create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0);
2428                         rtp->dtmfsamples = 0;
2429                 }
2430         } else if ((rtp->resp == resp) && !power) {
2431                 f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
2432                 f->samples = rtp->dtmfsamples * (rtp->lastrxformat.id ? (rtp_get_rate(&rtp->lastrxformat) / 1000) : 8);
2433                 rtp->resp = 0;
2434         } else if (rtp->resp == resp)
2435                 rtp->dtmfsamples += 20 * (rtp->lastrxformat.id ? (rtp_get_rate(&rtp->lastrxformat) / 1000) : 8);
2436
2437         rtp->dtmf_timeout = 0;
2438
2439         return f;
2440 }
2441
2442 static struct ast_frame *process_cn_rfc3389(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct ast_sockaddr *addr, int payloadtype, int mark)
2443 {
2444         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2445
2446         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
2447            totally help us out becuase we don't have an engine to keep it going and we are not
2448            guaranteed to have it every 20ms or anything */
2449         if (rtpdebug)
2450                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", (int) rtp->lastrxformat.id, len);
2451
2452         if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
2453                 struct ast_sockaddr remote_address = { {0,} };
2454
2455                 ast_rtp_instance_get_remote_address(instance, &remote_address);
2456
2457                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client address: %s\n",
2458                         ast_sockaddr_stringify(&remote_address));
2459                 ast_set_flag(rtp, FLAG_3389_WARNING);
2460         }
2461
2462         /* Must have at least one byte */
2463         if (!len)
2464                 return NULL;
2465         if (len < 24) {
2466                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
2467                 rtp->f.datalen = len - 1;
2468                 rtp->f.offset = AST_FRIENDLY_OFFSET;
2469                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
2470         } else {
2471                 rtp->f.data.ptr = NULL;
2472                 rtp->f.offset = 0;
2473                 rtp->f.datalen = 0;
2474         }
2475         rtp->f.frametype = AST_FRAME_CNG;
2476         rtp->f.subclass.integer = data[0] & 0x7f;
2477         rtp->f.samples = 0;
2478         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
2479
2480         return &rtp->f;
2481 }
2482
2483 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
2484 {
2485         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2486         struct ast_sockaddr addr;
2487         unsigned char rtcpdata[8192 + AST_FRIENDLY_OFFSET];
2488         unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
2489         int res, packetwords, position = 0;
2490         struct ast_frame *f = &ast_null_frame;
2491
2492         /* Read in RTCP data from the socket */
2493         if ((res = rtcp_recvfrom(instance, rtcpdata + AST_FRIENDLY_OFFSET,
2494                                 sizeof(rtcpdata) - AST_FRIENDLY_OFFSET,
2495                                 0, &addr)) < 0) {
2496                 ast_assert(errno != EBADF);
2497                 if (errno != EAGAIN) {
2498                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n",
2499                                 (errno) ? strerror(errno) : "Unspecified");
2500                         return NULL;
2501                 }
2502                 return &ast_null_frame;
2503         }
2504
2505         /* If this was handled by the ICE session don't do anything further */
2506         if (!res) {
2507                 return &ast_null_frame;
2508         }
2509
2510         if (!*(rtcpdata + AST_FRIENDLY_OFFSET)) {
2511                 struct sockaddr_in addr_tmp;
2512                 struct ast_sockaddr addr_v4;
2513
2514                 if (ast_sockaddr_is_ipv4(&addr)) {
2515                         ast_sockaddr_to_sin(&addr, &addr_tmp);
2516                 } else if (ast_sockaddr_ipv4_mapped(&addr, &addr_v4)) {
2517                         ast_debug(1, "Using IPv6 mapped address %s for STUN\n",
2518                                   ast_sockaddr_stringify(&addr));
2519                         ast_sockaddr_to_sin(&addr_v4, &addr_tmp);
2520                 } else {
2521                         ast_debug(1, "Cannot do STUN for non IPv4 address %s\n",
2522                                   ast_sockaddr_stringify(&addr));
2523                         return &ast_null_frame;
2524                 }
2525                 if ((ast_stun_handle_packet(rtp->rtcp->s, &addr_tmp, rtcpdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT)) {
2526                         ast_sockaddr_from_sin(&addr, &addr_tmp);
2527                         ast_sockaddr_copy(&rtp->rtcp->them, &addr);
2528                 }
2529                 return &ast_null_frame;
2530         }
2531
2532         packetwords = res / 4;
2533
2534         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
2535                 /* Send to whoever sent to us */
2536                 if (ast_sockaddr_cmp(&rtp->rtcp->them, &addr)) {
2537                         ast_sockaddr_copy(&rtp->rtcp->them, &addr);
2538                         if (rtpdebug)
2539                                 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s\n",
2540                                           ast_sockaddr_stringify(&rtp->rtcp->them));
2541                 }
2542         }
2543
2544         ast_debug(1, "Got RTCP report of %d bytes\n", res);
2545
2546         while (position < packetwords) {
2547                 int i, pt, rc;
2548                 unsigned int length, dlsr, lsr, msw, lsw, comp;
2549                 struct timeval now;
2550                 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
2551                 uint64_t rtt = 0;
2552
2553                 i = position;
2554                 length = ntohl(rtcpheader[i]);
2555                 pt = (length & 0xff0000) >> 16;
2556                 rc = (length & 0x1f000000) >> 24;
2557                 length &= 0xffff;
2558
2559                 if ((i + length) > packetwords) {
2560                         if (rtpdebug)
2561                                 ast_debug(1, "RTCP Read too short\n");
2562                         return &ast_null_frame;
2563                 }
2564
2565                 if (rtcp_debug_test_addr(&addr)) {
2566                         ast_verbose("\n\nGot RTCP from %s\n",
2567                                     ast_sockaddr_stringify(&addr));
2568                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
2569                         ast_verbose("Reception reports: %d\n", rc);
2570                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
2571                 }
2572
2573                 i += 2; /* Advance past header and ssrc */
2574                 if (rc == 0 && pt == RTCP_PT_RR) {      /* We're receiving a receiver report with no reports, which is ok */
2575                         position += (length + 1);
2576                         continue;
2577                 }
2578
2579                 switch (pt) {
2580                 case RTCP_PT_SR:
2581                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
2582                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
2583                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
2584                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
2585
2586                         if (rtcp_debug_test_addr(&addr)) {
2587                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
2588                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
2589                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
2590                         }
2591                         i += 5;
2592                         if (rc < 1)
2593                                 break;
2594                         /* Intentional fall through */
2595                 case RTCP_PT_RR:
2596                         /* Don't handle multiple reception reports (rc > 1) yet */
2597                         /* Calculate RTT per RFC */
2598                         gettimeofday(&now, NULL);
2599                         timeval2ntp(now, &msw, &lsw);
2600                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
2601                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
2602                                 lsr = ntohl(rtcpheader[i + 4]);
2603                                 dlsr = ntohl(rtcpheader[i + 5]);
2604                                 rtt = comp - lsr - dlsr;
2605
2606                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
2607                                    sess->ee_delay = (eedelay * 1000) / 65536; */
2608                                 if (rtt < 4294) {
2609                                         rtt = (rtt * 1000000) >> 16;
2610                                 } else {
2611                                         rtt = (rtt * 1000) >> 16;
2612                                         rtt *= 1000;
2613                                 }
2614                                 rtt = rtt / 1000.;
2615                                 rttsec = rtt / 1000.;
2616                                 rtp->rtcp->rtt = rttsec;
2617
2618                                 if (comp - dlsr >= lsr) {
2619                                         rtp->rtcp->accumulated_transit += rttsec;
2620
2621                                         if (rtp->rtcp->rtt_count == 0)
2622                                                 rtp->rtcp->minrtt = rttsec;
2623
2624                                         if (rtp->rtcp->maxrtt<rttsec)
2625                                                 rtp->rtcp->maxrtt = rttsec;
2626                                         if (rtp->rtcp->minrtt>rttsec)
2627                                                 rtp->rtcp->minrtt = rttsec;
2628
2629                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
2630
2631                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
2632
2633                                         rtp->rtcp->normdevrtt = normdevrtt_current;
2634
2635                                         rtp->rtcp->rtt_count++;
2636                                 } else if (rtcp_debug_test_addr(&addr)) {
2637                                         ast_verbose("Internal RTCP NTP clock skew detected: "
2638                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
2639                                                     "diff=%d\n",
2640                                                     lsr, comp, dlsr, dlsr / 65536,
2641                                                     (dlsr % 65536) * 1000 / 65536,
2642                                                     dlsr - (comp - lsr));
2643                                 }
2644                         }
2645
2646                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
2647                         reported_jitter = (double) rtp->rtcp->reported_jitter;
2648
2649                         if (rtp->rtcp->reported_jitter_count == 0)
2650                                 rtp->rtcp->reported_minjitter = reported_jitter;
2651
2652                         if (reported_jitter < rtp->rtcp->reported_minjitter)
2653                                 rtp->rtcp->reported_minjitter = reported_jitter;
2654
2655                         if (reported_jitter > rtp->rtcp->reported_maxjitter)
2656                                 rtp->rtcp->reported_maxjitter = reported_jitter;
2657
2658                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
2659
2660                         rtp->rtcp->reported_stdev_jitter = stddev_compute(rtp->rtcp->reported_stdev_jitter, reported_jitter, rtp->rtcp->reported_normdev_jitter, reported_normdev_jitter_current, rtp->rtcp->reported_jitter_count);
2661
2662                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
2663
2664                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
2665
2666                         reported_lost = (double) rtp->rtcp->reported_lost;
2667
2668                         /* using same counter as for jitter */
2669                         if (rtp->rtcp->reported_jitter_count == 0)
2670                                 rtp->rtcp->reported_minlost = reported_lost;
2671
2672                         if (reported_lost < rtp->rtcp->reported_minlost)
2673                                 rtp->rtcp->reported_minlost = reported_lost;
2674
2675                         if (reported_lost > rtp->rtcp->reported_maxlost)
2676                                 rtp->rtcp->reported_maxlost = reported_lost;
2677                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
2678
2679                         rtp->rtcp->reported_stdev_lost = stddev_compute(rtp->rtcp->reported_stdev_lost, reported_lost, rtp->rtcp->reported_normdev_lost, reported_normdev_lost_current, rtp->rtcp->reported_jitter_count);
2680
2681                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
2682
2683                         rtp->rtcp->reported_jitter_count++;
2684
2685                         if (rtcp_debug_test_addr(&addr)) {
2686                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
2687                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
2688                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
2689                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2])) >> 16);
2690                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
2691                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
2692                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
2693                                 if (rtt)
2694                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
2695                         }
2696                         if (rtt) {
2697                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s\r\n"
2698                                                                     "PT: %d(%s)\r\n"
2699                                                                     "ReceptionReports: %d\r\n"
2700                                                                     "SenderSSRC: %u\r\n"
2701                                                                     "FractionLost: %ld\r\n"
2702                                                                     "PacketsLost: %d\r\n"
2703                                                                     "HighestSequence: %ld\r\n"
2704                                                                     "SequenceNumberCycles: %ld\r\n"
2705                                                                     "IAJitter: %u\r\n"
2706                                                                     "LastSR: %lu.%010lu\r\n"
2707                                                                     "DLSR: %4.4f(sec)\r\n"
2708                                               "RTT: %llu(sec)\r\n",
2709                                               ast_sockaddr_stringify(&addr),
2710                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
2711                                               rc,
2712                                               rtcpheader[i + 1],
2713                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
2714                                               rtp->rtcp->reported_lost,
2715                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
2716                                               (long) (ntohl(rtcpheader[i + 2])) >> 16,
2717                                               rtp->rtcp->reported_jitter,
2718                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
2719                                               ntohl(rtcpheader[i + 5])/65536.0,
2720                                               (unsigned long long)rtt);
2721                         } else {
2722                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From: %s\r\n"
2723                                                                     "PT: %d(%s)\r\n"
2724                                                                     "ReceptionReports: %d\r\n"
2725                                                                     "SenderSSRC: %u\r\n"
2726                                                                     "FractionLost: %ld\r\n"
2727                                                                     "PacketsLost: %d\r\n"
2728                                                                     "HighestSequence: %ld\r\n"
2729                                                                     "SequenceNumberCycles: %ld\r\n"
2730                                                                     "IAJitter: %u\r\n"
2731                                                                     "LastSR: %lu.%010lu\r\n"
2732                                               "DLSR: %4.4f(sec)\r\n",
2733                                               ast_sockaddr_stringify(&addr),
2734                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
2735                                               rc,
2736                                               rtcpheader[i + 1],
2737                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
2738                                               rtp->rtcp->reported_lost,
2739                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
2740                                               (long) (ntohl(rtcpheader[i + 2])) >> 16,
2741                                               rtp->rtcp->reported_jitter,
2742                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
2743                                               ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
2744                                               ntohl(rtcpheader[i + 5])/65536.0);
2745                         }
2746                         break;
2747                 case RTCP_PT_FUR:
2748                         if (rtcp_debug_test_addr(&addr))
2749                                 ast_verbose("Received an RTCP Fast Update Request\n");
2750                         rtp->f.frametype = AST_FRAME_CONTROL;
2751                         rtp->f.subclass.integer = AST_CONTROL_VIDUPDATE;
2752                         rtp->f.datalen = 0;
2753                         rtp->f.samples = 0;
2754                         rtp->f.mallocd = 0;
2755                         rtp->f.src = "RTP";
2756                         f = &rtp->f;
2757                         break;
2758                 case RTCP_PT_SDES:
2759                         if (rtcp_debug_test_addr(&addr))
2760                                 ast_verbose("Received an SDES from %s\n",
2761                                             ast_sockaddr_stringify(&rtp->rtcp->them));
2762                         break;
2763                 case RTCP_PT_BYE:
2764                         if (rtcp_debug_test_addr(&addr))
2765                                 ast_verbose("Received a BYE from %s\n",
2766                                             ast_sockaddr_stringify(&rtp->rtcp->them));
2767                         break;
2768                 default:
2769                         ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s\n",
2770                                   pt, ast_sockaddr_stringify(&rtp->rtcp->them));
2771                         break;
2772                 }
2773                 position += (length + 1);
2774         }
2775
2776         rtp->rtcp->rtcp_info = 1;
2777
2778         return f;
2779 }
2780
2781 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
2782 {
2783         struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
2784         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
2785         int res = 0, payload = 0, bridged_payload = 0, mark;
2786         struct ast_rtp_payload_type payload_type;
2787         int reconstruct = ntohl(rtpheader[0]);
2788         struct ast_sockaddr remote_address = { {0,} };
2789         int ice;
2790
2791         /* Get fields from packet */
2792         payload = (reconstruct & 0x7f0000) >> 16;
2793         mark = (((reconstruct & 0x800000) >> 23) != 0);
2794
2795         /* Check what the payload value should be */
2796         payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
2797
2798         /* Otherwise adjust bridged payload to match */
2799         bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, &payload_type.format, payload_type.rtp_code);
2800
2801         /* If no codec could be matched between instance and instance1, then somehow things were made incompatible while we were still bridged.  Bail. */
2802         if (bridged_payload < 0) {
2803                 return -1;
2804         }
2805
2806         /* If the payload coming in is not one of the negotiated ones then send it to the core, this will cause formats to change and the bridge to break */
2807         if (ast_rtp_codecs_find_payload_code(ast_rtp_instance_get_codecs(instance1), bridged_payload) == -1) {
2808                 ast_debug(1, "Unsupported payload type received \n");
2809                 return -1;
2810         }
2811
2812         /* If the marker bit has been explicitly set turn it on */
2813         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
2814                 mark = 1;
2815                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
2816         }
2817
2818         /* Reconstruct part of the packet */
2819         reconstruct &= 0xFF80FFFF;
2820         reconstruct |= (bridged_payload << 16);
2821         reconstruct |= (mark << 23);
2822         rtpheader[0] = htonl(reconstruct);
2823
2824         ast_rtp_instance_get_remote_address(instance1, &remote_address);
2825
2826         if (ast_sockaddr_isnull(&remote_address)) {
2827                 ast_debug(1, "Remote address is null, most likely RTP has been stopped\n");
2828                 return 0;
2829         }
2830
2831         /* Send the packet back out */
2832         res = rtp_sendto(instance1, (void *)rtpheader, len, 0, &remote_address, &ice);
2833         if (res < 0) {
2834                 if (!ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) || (ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_NAT) && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2835                         ast_log(LOG_WARNING,
2836                                 "RTP Transmission error of packet to %s: %s\n",
2837                                 ast_sockaddr_stringify(&remote_address),
2838                                 strerror(errno));
2839                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
2840                         if (option_debug || rtpdebug)
2841                                 ast_log(LOG_WARNING,
2842                                         "RTP NAT: Can't write RTP to private "
2843                                         "address %s, waiting for other end to "
2844                                         "send audio...\n",
2845                                         ast_sockaddr_stringify(&remote_address));
2846                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
2847                 }
2848                 return 0;
2849         }
2850
2851         update_address_with_ice_candidate(rtp, COMPONENT_RTP, &remote_address);
2852
2853         if (rtp_debug_test_addr(&remote_address)) {
2854                 ast_verbose("Sent RTP P2P packet to %s%s (type %-2.2d, len %-6.6u)\n",
2855                             ast_sockaddr_stringify(&remote_address),
2856                             ice ? " (via ICE)" : "",
2857                             bridged_payload, len - hdrlen);
2858         }
2859
2860         return 0;
2861 }
2862
2863 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
2864 {
2865         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2866         struct ast_sockaddr addr;
2867         int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
2868         unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
2869         struct ast_rtp_payload_type payload;
2870         struct ast_sockaddr remote_address = { {0,} };
2871         struct frame_list frames;
2872
2873         /* If this is actually RTCP let's hop on over and handle it */
2874         if (rtcp) {
2875                 if (rtp->rtcp) {
2876                         return ast_rtcp_read(instance);
2877                 }
2878                 return &ast_null_frame;
2879         }
2880
2881         /* If we are currently sending DTMF to the remote party send a continuation packet */
2882         if (rtp->sending_digit) {
2883                 ast_rtp_dtmf_continuation(instance);
2884         }
2885
2886         /* Actually read in the data from the socket */
2887         if ((res = rtp_recvfrom(instance, rtp->rawdata + AST_FRIENDLY_OFFSET,
2888                                 sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0,
2889                                 &addr)) < 0) {
2890                 ast_assert(errno != EBADF);
2891                 if (errno != EAGAIN) {
2892                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n",
2893                                 (errno) ? strerror(errno) : "Unspecified");
2894                         return NULL;
2895                 }
2896                 return &ast_null_frame;
2897         }
2898
2899         /* If this was handled by the ICE session don't do anything */
2900         if (!res) {
2901                 return &ast_null_frame;
2902         }
2903
2904         /* Make sure the data that was read in is actually enough to make up an RTP packet */
2905         if (res < hdrlen) {
2906                 ast_log(LOG_WARNING, "RTP Read too short\n");
2907                 return &ast_null_frame;
2908         }
2909
2910         /* Get fields and verify this is an RTP packet */
2911         seqno = ntohl(rtpheader[0]);
2912
2913         ast_rtp_instance_get_remote_address(instance, &remote_address);
2914
2915         if (!(version = (seqno & 0xC0000000) >> 30)) {
2916                 struct sockaddr_in addr_tmp;
2917                 struct ast_sockaddr addr_v4;
2918                 if (ast_sockaddr_is_ipv4(&addr)) {
2919                         ast_sockaddr_to_sin(&addr, &addr_tmp);
2920                 } else if (ast_sockaddr_ipv4_mapped(&addr, &addr_v4)) {
2921                         ast_debug(1, "Using IPv6 mapped address %s for STUN\n",
2922                                   ast_sockaddr_stringify(&addr));
2923                         ast_sockaddr_to_sin(&addr_v4, &addr_tmp);
2924                 } else {
2925                         ast_debug(1, "Cannot do STUN for non IPv4 address %s\n",
2926                                   ast_sockaddr_stringify(&addr));
2927                         return &ast_null_frame;
2928                 }
2929                 if ((ast_stun_handle_packet(rtp->s, &addr_tmp, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
2930                     ast_sockaddr_isnull(&remote_address)) {
2931                         ast_sockaddr_from_sin(&addr, &addr_tmp);
2932                         ast_rtp_instance_set_remote_address(instance, &addr);
2933                 }
2934                 return &ast_null_frame;
2935         }
2936
2937         /* If strict RTP protection is enabled see if we need to learn the remote address or if we need to drop the packet */
2938         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
2939                 ast_debug(1, "%p -- start learning mode pass with addr = %s\n", rtp, ast_sockaddr_stringify(&addr));
2940                 /* For now, we always copy the address. */
2941                 ast_sockaddr_copy(&rtp->strict_rtp_address, &addr);
2942
2943                 /* Send the rtp and the seqno from header to rtp_learning_rtp_seq_update to see whether we can exit or not*/
2944                 if (rtp_learning_rtp_seq_update(rtp, ntohl(rtpheader[0]))) {
2945                         ast_debug(1, "%p -- Condition for learning hasn't exited, so reject the frame.\n", rtp);
2946                         return &ast_null_frame;
2947                 }
2948
2949                 ast_debug(1, "%p -- Probation Ended. Set strict_rtp_state to STRICT_RTP_CLOSED with address %s\n", rtp, ast_sockaddr_stringify(&addr));
2950                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
2951         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
2952                 if (ast_sockaddr_cmp(&rtp->strict_rtp_address, &addr)) {
2953                         /* Hmm, not the strict addres. Perhaps we're getting audio from the alternate? */
2954                         if (!ast_sockaddr_cmp(&rtp->alt_rtp_address, &addr)) {
2955                                 /* ooh, we did! You're now the new expected address, son! */
2956                                 ast_sockaddr_copy(&rtp->strict_rtp_address,
2957                                                   &addr);
2958                         } else  {
2959                                 const char *real_addr = ast_strdupa(ast_sockaddr_stringify(&addr));
2960                                 const char *expected_addr = ast_strdupa(ast_sockaddr_stringify(&rtp->strict_rtp_address));
2961
2962                                 ast_debug(1, "Received RTP packet from %s, dropping due to strict RTP protection. Expected it to be from %s\n",
2963                                                 real_addr, expected_addr);
2964
2965                                 return &ast_null_frame;
2966                         }
2967                 }
2968         }
2969
2970         /* If symmetric RTP is enabled see if the remote side is not what we expected and change where we are sending audio */
2971         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
2972                 if (ast_sockaddr_cmp(&remote_address, &addr)) {
2973                         ast_rtp_instance_set_remote_address(instance, &addr);
2974                         ast_sockaddr_copy(&remote_address, &addr);
2975                         if (rtp->rtcp) {
2976                                 ast_sockaddr_copy(&rtp->rtcp->them, &addr);
2977                                 ast_sockaddr_set_port(&rtp->rtcp->them, ast_sockaddr_port(&addr) + 1);
2978                         }
2979                         rtp->rxseqno = 0;
2980                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2981                         if (rtpdebug)
2982                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s\n",
2983                                           ast_sockaddr_stringify(&remote_address));
2984                 }
2985         }
2986
2987         /* If we are directly bridged to another instance send the audio directly out */
2988         if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
2989                 return &ast_null_frame;
2990         }
2991
2992         /* If the version is not what we expected by this point then just drop the packet */
2993         if (version != 2) {
2994                 return &ast_null_frame;
2995         }
2996
2997         /* Pull out the various other fields we will need */
2998         payloadtype = (seqno & 0x7f0000) >> 16;
2999         padding = seqno & (1 << 29);
3000         mark = seqno & (1 << 23);
3001         ext = seqno & (1 << 28);
3002         cc = (seqno & 0xF000000) >> 24;
3003         seqno &= 0xffff;
3004         timestamp = ntohl(rtpheader[1]);
3005         ssrc = ntohl(rtpheader[2]);
3006
3007         AST_LIST_HEAD_INIT_NOLOCK(&frames);
3008         /* Force a marker bit and change SSRC if the SSRC changes */
3009         if (rtp->rxssrc && rtp->rxssrc != ssrc) {
3010                 struct ast_frame *f, srcupdate = {
3011                         AST_FRAME_CONTROL,
3012                         .subclass.integer = AST_CONTROL_SRCCHANGE,
3013                 };
3014
3015                 if (!mark) {
3016                         if (rtpdebug) {
3017                                 ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
3018                         }
3019                         mark = 1;
3020                 }
3021
3022                 f = ast_frisolate(&srcupdate);
3023                 AST_LIST_INSERT_TAIL(&frames, f, frame_list);
3024         }
3025
3026         rtp->rxssrc = ssrc;
3027
3028         /* Remove any padding bytes that may be present */
3029         if (padding) {
3030                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
3031         }
3032
3033         /* Skip over any CSRC fields */
3034         if (cc) {
3035                 hdrlen += cc * 4;
3036         }
3037
3038         /* Look for any RTP extensions, currently we do not support any */
3039         if (ext) {
3040                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
3041                 hdrlen += 4;
3042                 if (option_debug) {
3043                         int profile;
3044                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
3045                         if (profile == 0x505a)
3046                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
3047                         else
3048                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
3049                 }
3050         }
3051
3052         /* Make sure after we potentially mucked with the header length that it is once again valid */
3053         if (res < hdrlen) {
3054                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
3055                 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
3056         }
3057
3058         rtp->rxcount++;
3059         if (rtp->rxcount == 1) {
3060                 rtp->seedrxseqno = seqno;
3061         }
3062
3063         /* Do not schedule RR if RTCP isn't run */
3064         if (rtp->rtcp && !ast_sockaddr_isnull(&rtp->rtcp->them) && rtp->rtcp->schedid < 1) {
3065                 /* Schedule transmission of Receiver Report */
3066                 ao2_ref(instance, +1);
3067                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
3068                 if (rtp->rtcp->schedid < 0) {
3069                         ao2_ref(instance, -1);
3070                         ast_log(LOG_WARNING, "scheduling RTCP transmission failed.\n");
3071                 }
3072         }
3073         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
3074                 rtp->cycles += RTP_SEQ_MOD;
3075
3076         prev_seqno = rtp->lastrxseqno;
3077         rtp->lastrxseqno = seqno;
3078
3079         if (!rtp->themssrc) {
3080                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
3081         }
3082
3083         if (rtp_debug_test_addr(&addr)) {
3084                 ast_verbose("Got  RTP packet from    %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
3085                             ast_sockaddr_stringify(&addr),
3086                             payloadtype, seqno, timestamp,res - hdrlen);
3087         }
3088
3089         payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
3090
3091         /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
3092         if (!payload.asterisk_format) {
3093                 struct ast_frame *f = NULL;
3094                 if (payload.rtp_code == AST_RTP_DTMF) {
3095                         /* process_dtmf_rfc2833 may need to return multiple frames. We do this
3096                          * by passing the pointer to the frame list to it so that the method
3097                          * can append frames to the list as needed.
3098                          */
3099                         process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark, &frames);
3100                 } else if (payload.rtp_code == AST_RTP_CISCO_DTMF) {
3101                         f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
3102                 } else if (payload.rtp_code == AST_RTP_CN) {
3103                         f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
3104                 } else {
3105                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n",
3106                                 payloadtype,
3107                                 ast_sockaddr_stringify(&remote_address));
3108                 }
3109
3110                 if (f) {
3111                         AST_LIST_INSERT_TAIL(&frames, f, frame_list);
3112                 }
3113                 /* Even if no frame was returned by one of the above methods,
3114                  * we may have a frame to return in our frame list
3115                  */
3116                 if (!AST_LIST_EMPTY(&frames)) {
3117                         return AST_LIST_FIRST(&frames);
3118                 }
3119                 return &ast_null_frame;
3120         }
3121
3122         ast_format_copy(&rtp->lastrxformat, &payload.format);
3123         ast_format_copy(&rtp->f.subclass.format, &payload.format);
3124         rtp->f.frametype = (AST_FORMAT_GET_TYPE(rtp->f.subclass.format.id) == AST_FORMAT_TYPE_AUDIO) ? AST_FRAME_VOICE : (AST_FORMAT_GET_TYPE(rtp->f.subclass.format.id) == AST_FORMAT_TYPE_VIDEO) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
3125
3126         rtp->rxseqno = seqno;
3127
3128         if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
3129                 rtp->dtmf_timeout = 0;
3130
3131                 if (rtp->resp) {
3132                         struct ast_frame *f;
3133                         f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0);
3134                         f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(&f->subclass.format)), ast_tv(0, 0));
3135                         rtp->resp = 0;
3136                         rtp->dtmf_timeout = rtp->dtmf_duration = 0;
3137                         AST_LIST_INSERT_TAIL(&frames, f, frame_list);
3138                         return AST_LIST_FIRST(&frames);
3139                 }
3140         }
3141
3142         rtp->lastrxts = timestamp;
3143
3144         rtp->f.src = "RTP";
3145         rtp->f.mallocd = 0;
3146         rtp->f.datalen = res - hdrlen;
3147         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
3148         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
3149         rtp->f.seqno = seqno;
3150
3151         if (rtp->f.subclass.format.id == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
3152                 unsigned char *data = rtp->f.data.ptr;
3153
3154                 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
3155                 rtp->f.datalen +=3;
3156                 *data++ = 0xEF;
3157                 *data++ = 0xBF;
3158                 *data = 0xBD;
3159         }
3160
3161         if (rtp->f.subclass.format.id == AST_FORMAT_T140RED) {
3162                 unsigned char *data = rtp->f.data.ptr;
3163                 unsigned char *header_end;
3164                 int num_generations;
3165                 int header_length;
3166                 int len;
3167                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
3168                 int x;
3169
3170                 ast_format_set(&rtp->f.subclass.format, AST_FORMAT_T140, 0);
3171                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
3172                 if (header_end == NULL) {
3173                         return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
3174                 }
3175                 header_end++;
3176
3177                 header_length = header_end - data;
3178                 num_generations = header_length / 4;
3179                 len = header_length;
3180
3181                 if (!diff) {
3182                         for (x = 0; x < num_generations; x++)
3183                                 len += data[x * 4 + 3];
3184
3185                         if (!(rtp->f.datalen - len))
3186                                 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
3187
3188                         rtp->f.data.ptr += len;
3189                         rtp->f.datalen -= len;
3190                 } else if (diff > num_generations && diff < 10) {
3191                         len -= 3;
3192                         rtp->f.data.ptr += len;
3193                         rtp->f.datalen -= len;
3194
3195                         data = rtp->f.data.ptr;
3196                         *data++ = 0xEF;
3197                         *data++ = 0xBF;
3198                         *data = 0xBD;
3199                 } else {
3200                         for ( x = 0; x < num_generations - diff; x++)
3201                                 len += data[x * 4 + 3];
3202
3203                         rtp->f.data.ptr += len;
3204                         rtp->f.datalen -= len;
3205                 }
3206         }
3207
3208         if (AST_FORMAT_GET_TYPE(rtp->f.subclass.format.id) == AST_FORMAT_TYPE_AUDIO) {
3209                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
3210                 if (ast_format_is_slinear(&rtp->f.subclass.format)) {
3211                         ast_frame_byteswap_be(&rtp->f);
3212                 }
3213                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
3214                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
3215                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
3216                 rtp->f.ts = timestamp / (rtp_get_rate(&rtp->f.subclass.format) / 1000);
3217                 rtp->f.len = rtp->f.samples / ((ast_format_rate(&rtp->f.subclass.format) / 1000));
3218         } else if (AST_FORMAT_GET_TYPE(rtp->f.subclass.format.id) == AST_FORMAT_TYPE_VIDEO) {
3219                 /* Video -- samples is # of samples vs. 90000 */
3220                 if (!rtp->lastividtimestamp)
3221                         rtp->lastividtimestamp = timestamp;
3222                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
3223                 rtp->lastividtimestamp = timestamp;
3224                 rtp->f.delivery.tv_sec = 0;
3225                 rtp->f.delivery.tv_usec = 0;
3226                 /* Pass the RTP marker bit as bit */
3227                 if (mark) {
3228                         ast_format_set_video_mark(&rtp->f.subclass.format);
3229                 }
3230         } else {
3231                 /* TEXT -- samples is # of samples vs. 1000 */
3232                 if (!rtp->lastitexttimestamp)
3233                         rtp->lastitexttimestamp = timestamp;
3234                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
3235                 rtp->lastitexttimestamp = timestamp;
3236                 rtp->f.delivery.tv_sec = 0;
3237                 rtp->f.delivery.tv_usec = 0;
3238         }
3239
3240         AST_LIST_INSERT_TAIL(&frames, &rtp->f, frame_list);
3241         return AST_LIST_FIRST(&frames);
3242 }
3243
3244 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
3245 {
3246         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3247
3248         if (property == AST_RTP_PROPERTY_RTCP) {
3249                 if (value) {
3250                         if (rtp->rtcp) {
3251                                 ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
3252                                 return;
3253                         }
3254                         /* Setup RTCP to be activated on the next RTP write */
3255                         if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
3256                                 return;
3257                         }
3258
3259                         /* Grab the IP address and port we are going to use */
3260                         ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
3261                         ast_sockaddr_set_port(&rtp->rtcp->us,
3262                                               ast_sockaddr_port(&rtp->rtcp->us) + 1);
3263
3264                         if ((rtp->rtcp->s =
3265                              create_new_socket("RTCP",
3266                                                ast_sockaddr_is_ipv4(&rtp->rtcp->us) ?
3267                                                AF_INET :
3268                                                ast_sockaddr_is_ipv6(&rtp->rtcp->us) ?
3269                                                AF_INET6 : -1)) < 0) {
3270                                 ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
3271                                 ast_free(rtp->rtcp);
3272                                 rtp->rtcp = NULL;
3273                                 return;
3274                         }
3275
3276                         /* Try to actually bind to the IP address and port we are going to use for RTCP, if this fails we have to bail out */
3277                         if (ast_bind(rtp->rtcp->s, &rtp->rtcp->us)) {
3278                                 ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
3279                                 close(rtp->rtcp->s);
3280                                 ast_free(rtp->rtcp);
3281                                 rtp->rtcp = NULL;
3282                                 return;
3283                         }
3284
3285                         ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
3286                         rtp->rtcp->schedid = -1;
3287
3288                         if (rtp->ice) {
3289                                 rtp_add_candidates_to_ice(instance, rtp, &rtp->rtcp->us, ast_sockaddr_port(&rtp->rtcp->us), COMPONENT_RTCP, TRANSPORT_SOCKET_RTCP,
3290                                                           &ast_rtp_turn_rtcp_sock_cb, &rtp->turn_rtcp);
3291                         }
3292
3293                         return;
3294                 } else {
3295                         if (rtp->rtcp) {
3296                                 if (rtp->rtcp->schedid > 0) {
3297                                         if (!ast_sched_del(rtp->sched, rtp->rtcp->schedid)) {
3298                                                 /* Successfully cancelled scheduler entry. */
3299                                                 ao2_ref(instance, -1);
3300                                         } else {
3301                                                 /* Unable to cancel scheduler entry */
3302                                                 ast_debug(1, "Failed to tear down RTCP on RTP instance '%p'\n", instance);
3303                                                 return;
3304                                         }
3305                                         rtp->rtcp->schedid = -1;
3306                                 }
3307                                 close(rtp->rtcp->s);
3308                                 ast_free(rtp->rtcp);
3309                                 rtp->rtcp = NULL;
3310                         }
3311                         return;
3312                 }
3313         }
3314
3315         return;
3316 }
3317
3318 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
3319 {
3320         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3321
3322         return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
3323 }
3324
3325 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
3326 {
3327         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3328
3329         if (rtp->rtcp) {
3330                 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
3331                 ast_sockaddr_copy(&rtp->rtcp->them, addr);
3332                 if (!ast_sockaddr_isnull(addr)) {
3333                         ast_sockaddr_set_port(&rtp->rtcp->them,
3334                                               ast_sockaddr_port(addr) + 1);
3335                 }
3336         }
3337
3338         rtp->rxseqno = 0;
3339
3340         if (strictrtp) {
3341                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
3342                 rtp_learning_seq_init(rtp, rtp->seqno);
3343         }
3344
3345         return;
3346 }
3347
3348 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
3349 {
3350         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3351
3352         /* No need to futz with rtp->rtcp here because ast_rtcp_read is already able to adjust if receiving
3353          * RTCP from an "unexpected" source
3354          */
3355         ast_sockaddr_copy(&rtp->alt_rtp_address, addr);
3356
3357         return;
3358 }
3359
3360 /*! \brief Write t140 redundacy frame
3361  * \param data primary data to be buffered
3362  */
3363 static int red_write(const void *data)
3364 {
3365         struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
3366         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3367
3368         ast_rtp_write(instance, &rtp->red->t140);
3369
3370         return 1;
3371 }
3372
3373 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
3374 {
3375         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3376         int x;
3377
3378         if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
3379                 return -1;
3380         }
3381
3382         rtp->red->t140.frametype = AST_FRAME_TEXT;
3383         ast_format_set(&rtp->red->t140.subclass.format, AST_FORMAT_T140RED, 0);
3384         rtp->red->t140.data.ptr = &rtp->red->buf_data;
3385
3386         rtp->red->t140.ts = 0;
3387         rtp->red->t140red = rtp->red->t140;
3388         rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
3389         rtp->red->t140red.datalen = 0;
3390         rtp->red->ti = buffer_time;
3391         rtp->red->num_gen = generations;
3392         rtp->red->hdrlen = generations * 4 + 1;
3393         rtp->red->prev_ts = 0;
3394
3395         for (x = 0; x < generations; x++) {
3396                 rtp->red->pt[x] = payloads[x];
3397                 rtp->red->pt[x] |= 1 << 7; /* mark redundant generations pt */
3398                 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
3399         }
3400         rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x]; /* primary pt */
3401         rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
3402
3403         rtp->red->t140.datalen = 0;
3404
3405         return 0;
3406 }
3407
3408 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
3409 {
3410         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3411
3412         if (frame->datalen > -1) {
3413                 struct rtp_red *red = rtp->red;
3414                 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
3415                 red->t140.datalen += frame->datalen;
3416                 red->t140.ts = frame->ts;
3417         }
3418
3419         return 0;
3420 }
3421
3422 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
3423 {
3424         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
3425
3426         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
3427
3428         return 0;
3429 }
3430
3431 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
3432 {
3433         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
3434
3435         if (!rtp->rtcp) {
3436                 return -1;
3437         }
3438
3439         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
3440         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
3441
3442         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
3443         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->rxploss, rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
3444         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
3445         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
3446         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lo