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