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