rtp timestamp to timeval calculation fix
[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 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include <sys/time.h>
36 #include <signal.h>
37 #include <fcntl.h>
38 #include <math.h>
39
40 #include "asterisk/stun.h"
41 #include "asterisk/pbx.h"
42 #include "asterisk/frame.h"
43 #include "asterisk/channel.h"
44 #include "asterisk/acl.h"
45 #include "asterisk/config.h"
46 #include "asterisk/lock.h"
47 #include "asterisk/utils.h"
48 #include "asterisk/netsock.h"
49 #include "asterisk/cli.h"
50 #include "asterisk/manager.h"
51 #include "asterisk/unaligned.h"
52 #include "asterisk/module.h"
53 #include "asterisk/rtp_engine.h"
54
55 #define MAX_TIMESTAMP_SKEW      640
56
57 #define RTP_SEQ_MOD     (1<<16) /*!< A sequence number can't be more than 16 bits */
58 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
59 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
60 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
61
62 #define DEFAULT_RTP_START 5000 /*!< Default port number to start allocating RTP ports from */
63 #define DEFAULT_RTP_END 31000  /*!< Default maximum port number to end allocating RTP ports at */
64
65 #define MINIMUM_RTP_PORT 1024 /*!< Minimum port number to accept */
66 #define MAXIMUM_RTP_PORT 65535 /*!< Maximum port number to accept */
67
68 #define RTCP_PT_FUR     192
69 #define RTCP_PT_SR      200
70 #define RTCP_PT_RR      201
71 #define RTCP_PT_SDES    202
72 #define RTCP_PT_BYE     203
73 #define RTCP_PT_APP     204
74
75 #define RTP_MTU         1200
76
77 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))      /*!< samples */
78
79 #define ZFONE_PROFILE_ID 0x505a
80
81 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
82
83 static int rtpstart = DEFAULT_RTP_START;                        /*!< First port for RTP sessions (set in rtp.conf) */
84 static int rtpend = DEFAULT_RTP_END;                    /*!< Last port for RTP sessions (set in rtp.conf) */
85 static int rtpdebug;                    /*!< Are we debugging? */
86 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
87 static int rtcpstats;                   /*!< Are we debugging RTCP? */
88 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
89 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
90 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
91 #ifdef SO_NO_CHECK
92 static int nochecksums;
93 #endif
94 static int strictrtp;
95
96 enum strict_rtp_state {
97         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
98         STRICT_RTP_LEARN,    /*! Accept next packet as source */
99         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
100 };
101
102 #define FLAG_3389_WARNING               (1 << 0)
103 #define FLAG_NAT_ACTIVE                 (3 << 1)
104 #define FLAG_NAT_INACTIVE               (0 << 1)
105 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
106 #define FLAG_NEED_MARKER_BIT            (1 << 3)
107 #define FLAG_DTMF_COMPENSATE            (1 << 4)
108
109 /*! \brief RTP session description */
110 struct ast_rtp {
111         int s;
112         struct ast_frame f;
113         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
114         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
115         unsigned int themssrc;          /*!< Their SSRC */
116         unsigned int rxssrc;
117         unsigned int lastts;
118         unsigned int lastrxts;
119         unsigned int lastividtimestamp;
120         unsigned int lastovidtimestamp;
121         unsigned int lastitexttimestamp;
122         unsigned int lastotexttimestamp;
123         unsigned int lasteventseqn;
124         int lastrxseqno;                /*!< Last received sequence number */
125         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
126         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
127         unsigned int rxcount;           /*!< How many packets have we received? */
128         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
129         unsigned int txcount;           /*!< How many packets have we sent? */
130         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
131         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
132         double rxjitter;                /*!< Interarrival jitter at the moment */
133         double rxtransit;               /*!< Relative transit time for previous packet */
134         format_t lasttxformat;
135         format_t lastrxformat;
136
137         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
138         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
139         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
140
141         /* DTMF Reception Variables */
142         char resp;
143         unsigned int lastevent;
144         unsigned int dtmf_duration;     /*!< Total duration in samples since the digit start event */
145         unsigned int dtmf_timeout;      /*!< When this timestamp is reached we consider END frame lost and forcibly abort digit */
146         unsigned int dtmfsamples;
147         /* DTMF Transmission Variables */
148         unsigned int lastdigitts;
149         char sending_digit;     /*!< boolean - are we sending digits */
150         char send_digit;        /*!< digit we are sending */
151         int send_payload;
152         int send_duration;
153         unsigned int flags;
154         struct timeval rxcore;
155         struct timeval txcore;
156         double drxcore;                 /*!< The double representation of the first received packet */
157         struct timeval lastrx;          /*!< timeval when we last received a packet */
158         struct timeval dtmfmute;
159         struct ast_smoother *smoother;
160         int *ioid;
161         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
162         unsigned short rxseqno;
163         struct sched_context *sched;
164         struct io_context *io;
165         void *data;
166         struct ast_rtcp *rtcp;
167         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
168
169         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
170         struct sockaddr_in strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
171         struct sockaddr_in alt_rtp_address; /*!<Alternate remote address information */
172
173         struct rtp_red *red;
174 };
175
176 /*!
177  * \brief Structure defining an RTCP session.
178  *
179  * The concept "RTCP session" is not defined in RFC 3550, but since
180  * this structure is analogous to ast_rtp, which tracks a RTP session,
181  * it is logical to think of this as a RTCP session.
182  *
183  * RTCP packet is defined on page 9 of RFC 3550.
184  *
185  */
186 struct ast_rtcp {
187         int rtcp_info;
188         int s;                          /*!< Socket */
189         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
190         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
191         unsigned int soc;               /*!< What they told us */
192         unsigned int spc;               /*!< What they told us */
193         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
194         struct timeval rxlsr;           /*!< Time when we got their last SR */
195         struct timeval txlsr;           /*!< Time when we sent or last SR*/
196         unsigned int expected_prior;    /*!< no. packets in previous interval */
197         unsigned int received_prior;    /*!< no. packets received in previous interval */
198         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
199         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
200         unsigned int sr_count;          /*!< number of SRs we've sent */
201         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
202         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
203         double rtt;                     /*!< Last reported rtt */
204         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
205         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
206
207         double reported_maxjitter;
208         double reported_minjitter;
209         double reported_normdev_jitter;
210         double reported_stdev_jitter;
211         unsigned int reported_jitter_count;
212
213         double reported_maxlost;
214         double reported_minlost;
215         double reported_normdev_lost;
216         double reported_stdev_lost;
217
218         double rxlost;
219         double maxrxlost;
220         double minrxlost;
221         double normdev_rxlost;
222         double stdev_rxlost;
223         unsigned int rxlost_count;
224
225         double maxrxjitter;
226         double minrxjitter;
227         double normdev_rxjitter;
228         double stdev_rxjitter;
229         unsigned int rxjitter_count;
230         double maxrtt;
231         double minrtt;
232         double normdevrtt;
233         double stdevrtt;
234         unsigned int rtt_count;
235 };
236
237 struct rtp_red {
238         struct ast_frame t140;  /*!< Primary data  */
239         struct ast_frame t140red;   /*!< Redundant t140*/
240         unsigned char pt[AST_RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
241         unsigned char ts[AST_RED_MAX_GENERATION]; /*!< Time stamps */
242         unsigned char len[AST_RED_MAX_GENERATION]; /*!< length of each generation */
243         int num_gen; /*!< Number of generations */
244         int schedid; /*!< Timer id */
245         int ti; /*!< How long to buffer data before send */
246         unsigned char t140red_data[64000];
247         unsigned char buf_data[64000]; /*!< buffered primary data */
248         int hdrlen;
249         long int prev_ts;
250 };
251
252 /* Forward Declarations */
253 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct sockaddr_in *sin, void *data);
254 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
255 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
256 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
257 static void ast_rtp_new_source(struct ast_rtp_instance *instance);
258 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame);
259 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp);
260 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value);
261 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp);
262 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
263 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin);
264 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations);
265 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame);
266 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1);
267 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat);
268 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1);
269 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username);
270 static void ast_rtp_stop(struct ast_rtp_instance *instance);
271
272 /* RTP Engine Declaration */
273 static struct ast_rtp_engine asterisk_rtp_engine = {
274         .name = "asterisk",
275         .new = ast_rtp_new,
276         .destroy = ast_rtp_destroy,
277         .dtmf_begin = ast_rtp_dtmf_begin,
278         .dtmf_end = ast_rtp_dtmf_end,
279         .new_source = ast_rtp_new_source,
280         .write = ast_rtp_write,
281         .read = ast_rtp_read,
282         .prop_set = ast_rtp_prop_set,
283         .fd = ast_rtp_fd,
284         .remote_address_set = ast_rtp_remote_address_set,
285         .alt_remote_address_set = ast_rtp_alt_remote_address_set,
286         .red_init = rtp_red_init,
287         .red_buffer = rtp_red_buffer,
288         .local_bridge = ast_rtp_local_bridge,
289         .get_stat = ast_rtp_get_stat,
290         .dtmf_compatible = ast_rtp_dtmf_compatible,
291         .stun_request = ast_rtp_stun_request,
292         .stop = ast_rtp_stop,
293 };
294
295 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
296 {
297         if (!rtpdebug) {
298                 return 0;
299         }
300
301         if (rtpdebugaddr.sin_addr.s_addr) {
302                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
303                      && (rtpdebugaddr.sin_port != addr->sin_port))
304                     || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
305                         return 0;
306         }
307
308         return 1;
309 }
310
311 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
312 {
313         if (!rtcpdebug) {
314                 return 0;
315         }
316
317         if (rtcpdebugaddr.sin_addr.s_addr) {
318                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
319                      && (rtcpdebugaddr.sin_port != addr->sin_port))
320                     || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
321                         return 0;
322         }
323
324         return 1;
325 }
326
327 static int rtp_get_rate(format_t subclass)
328 {
329         return (subclass == AST_FORMAT_G722) ? 8000 : ast_format_rate(subclass);
330 }
331
332 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
333 {
334         unsigned int interval;
335         /*! \todo XXX Do a more reasonable calculation on this one
336          * Look in RFC 3550 Section A.7 for an example*/
337         interval = rtcpinterval;
338         return interval;
339 }
340
341 /*! \brief Calculate normal deviation */
342 static double normdev_compute(double normdev, double sample, unsigned int sample_count)
343 {
344         normdev = normdev * sample_count + sample;
345         sample_count++;
346
347         return normdev / sample_count;
348 }
349
350 static double stddev_compute(double stddev, double sample, double normdev, double normdev_curent, unsigned int sample_count)
351 {
352 /*
353                 for the formula check http://www.cs.umd.edu/~austinjp/constSD.pdf
354                 return sqrt( (sample_count*pow(stddev,2) + sample_count*pow((sample-normdev)/(sample_count+1),2) + pow(sample-normdev_curent,2)) / (sample_count+1));
355                 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
356                 optimized formula
357 */
358 #define SQUARE(x) ((x) * (x))
359
360         stddev = sample_count * stddev;
361         sample_count++;
362
363         return stddev +
364                 ( sample_count * SQUARE( (sample - normdev) / sample_count ) ) +
365                 ( SQUARE(sample - normdev_curent) / sample_count );
366
367 #undef SQUARE
368 }
369
370 static int create_new_socket(const char *type)
371 {
372         int sock = socket(AF_INET, SOCK_DGRAM, 0);
373
374         if (sock < 0) {
375                 if (!type) {
376                         type = "RTP/RTCP";
377                 }
378                 ast_log(LOG_WARNING, "Unable to allocate %s socket: %s\n", type, strerror(errno));
379         } else {
380                 long flags = fcntl(sock, F_GETFL);
381                 fcntl(sock, F_SETFL, flags | O_NONBLOCK);
382 #ifdef SO_NO_CHECK
383                 if (nochecksums) {
384                         setsockopt(sock, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
385                 }
386 #endif
387         }
388
389         return sock;
390 }
391
392 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct sockaddr_in *sin, void *data)
393 {
394         struct ast_rtp *rtp = NULL;
395         int x, startplace;
396
397         /* Create a new RTP structure to hold all of our data */
398         if (!(rtp = ast_calloc(1, sizeof(*rtp)))) {
399                 return -1;
400         }
401
402         /* Set default parameters on the newly created RTP structure */
403         rtp->ssrc = ast_random();
404         rtp->seqno = ast_random() & 0xffff;
405         rtp->strict_rtp_state = (strictrtp ? STRICT_RTP_LEARN : STRICT_RTP_OPEN);
406
407         /* Create a new socket for us to listen on and use */
408         if ((rtp->s = create_new_socket("RTP")) < 0) {
409                 ast_debug(1, "Failed to create a new socket for RTP instance '%p'\n", instance);
410                 ast_free(rtp);
411                 return -1;
412         }
413
414         /* Now actually find a free RTP port to use */
415         x = (rtpend == rtpstart) ? rtpstart : (ast_random() % (rtpend - rtpstart)) + rtpstart;
416         x = x & ~1;
417         startplace = x;
418
419         for (;;) {
420                 sin->sin_port = htons(x);
421                 /* Try to bind, this will tell us whether the port is available or not */
422                 if (!bind(rtp->s, (struct sockaddr *)sin, sizeof(*sin))) {
423                         ast_debug(1, "Allocated port %d for RTP instance '%p'\n", x, instance);
424                         ast_rtp_instance_set_local_address(instance, sin);
425                         break;
426                 }
427
428                 x += 2;
429                 if (x > rtpend) {
430                         x = (rtpstart + 1) & ~1;
431                 }
432
433                 /* See if we ran out of ports or if the bind actually failed because of something other than the address being in use */
434                 if (x == startplace || errno != EADDRINUSE) {
435                         ast_log(LOG_ERROR, "Oh dear... we couldn't allocate a port for RTP instance '%p'\n", instance);
436                         return -1;
437                 }
438         }
439
440         /* Record any information we may need */
441         rtp->sched = sched;
442
443         /* Associate the RTP structure with the RTP instance and be done */
444         ast_rtp_instance_set_data(instance, rtp);
445
446         return 0;
447 }
448
449 static int ast_rtp_destroy(struct ast_rtp_instance *instance)
450 {
451         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
452
453         /* Destroy the smoother that was smoothing out audio if present */
454         if (rtp->smoother) {
455                 ast_smoother_free(rtp->smoother);
456         }
457
458         /* Close our own socket so we no longer get packets */
459         if (rtp->s > -1) {
460                 close(rtp->s);
461         }
462
463         /* Destroy RTCP if it was being used */
464         if (rtp->rtcp) {
465                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
466                 close(rtp->rtcp->s);
467                 ast_free(rtp->rtcp);
468         }
469
470         /* Destroy RED if it was being used */
471         if (rtp->red) {
472                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
473                 ast_free(rtp->red);
474         }
475
476         /* Finally destroy ourselves */
477         ast_free(rtp);
478
479         return 0;
480 }
481
482 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit)
483 {
484         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
485         struct sockaddr_in remote_address = { 0, };
486         int hdrlen = 12, res = 0, i = 0, payload = 101;
487         char data[256];
488         unsigned int *rtpheader = (unsigned int*)data;
489
490         ast_rtp_instance_get_remote_address(instance, &remote_address);
491
492         /* If we have no remote address information bail out now */
493         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
494                 return -1;
495         }
496
497         /* Convert given digit into what we want to transmit */
498         if ((digit <= '9') && (digit >= '0')) {
499                 digit -= '0';
500         } else if (digit == '*') {
501                 digit = 10;
502         } else if (digit == '#') {
503                 digit = 11;
504         } else if ((digit >= 'A') && (digit <= 'D')) {
505                 digit = digit - 'A' + 12;
506         } else if ((digit >= 'a') && (digit <= 'd')) {
507                 digit = digit - 'a' + 12;
508         } else {
509                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
510                 return -1;
511         }
512
513         /* Grab the payload that they expect the RFC2833 packet to be received in */
514         payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 0, AST_RTP_DTMF);
515
516         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
517         rtp->send_duration = 160;
518         rtp->lastdigitts = rtp->lastts + rtp->send_duration;
519
520         /* Create the actual packet that we will be sending */
521         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
522         rtpheader[1] = htonl(rtp->lastdigitts);
523         rtpheader[2] = htonl(rtp->ssrc);
524
525         /* Actually send the packet */
526         for (i = 0; i < 2; i++) {
527                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
528                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
529                 if (res < 0) {
530                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
531                                 ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
532                 }
533                 if (rtp_debug_test_addr(&remote_address)) {
534                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
535                                     ast_inet_ntoa(remote_address.sin_addr),
536                                     ntohs(remote_address.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
537                 }
538                 rtp->seqno++;
539                 rtp->send_duration += 160;
540                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
541         }
542
543         /* Record that we are in the process of sending a digit and information needed to continue doing so */
544         rtp->sending_digit = 1;
545         rtp->send_digit = digit;
546         rtp->send_payload = payload;
547
548         return 0;
549 }
550
551 static int ast_rtp_dtmf_continuation(struct ast_rtp_instance *instance)
552 {
553         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
554         struct sockaddr_in remote_address = { 0, };
555         int hdrlen = 12, res = 0;
556         char data[256];
557         unsigned int *rtpheader = (unsigned int*)data;
558
559         ast_rtp_instance_get_remote_address(instance, &remote_address);
560
561         /* Make sure we know where the other side is so we can send them the packet */
562         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
563                 return -1;
564         }
565
566         /* Actually create the packet we will be sending */
567         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
568         rtpheader[1] = htonl(rtp->lastdigitts);
569         rtpheader[2] = htonl(rtp->ssrc);
570         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
571         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
572
573         /* Boom, send it on out */
574         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
575         if (res < 0) {
576                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
577                         ast_inet_ntoa(remote_address.sin_addr),
578                         ntohs(remote_address.sin_port), strerror(errno));
579         }
580
581         if (rtp_debug_test_addr(&remote_address)) {
582                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
583                             ast_inet_ntoa(remote_address.sin_addr),
584                             ntohs(remote_address.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
585         }
586
587         /* And now we increment some values for the next time we swing by */
588         rtp->seqno++;
589         rtp->send_duration += 160;
590
591         return 0;
592 }
593
594 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit)
595 {
596         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
597         struct sockaddr_in remote_address = { 0, };
598         int hdrlen = 12, res = 0, i = 0;
599         char data[256];
600         unsigned int *rtpheader = (unsigned int*)data;
601
602         ast_rtp_instance_get_remote_address(instance, &remote_address);
603
604         /* Make sure we know where the remote side is so we can send them the packet we construct */
605         if (!remote_address.sin_addr.s_addr || !remote_address.sin_port) {
606                 return -1;
607         }
608
609         /* Convert the given digit to the one we are going to send */
610         if ((digit <= '9') && (digit >= '0')) {
611                 digit -= '0';
612         } else if (digit == '*') {
613                 digit = 10;
614         } else if (digit == '#') {
615                 digit = 11;
616         } else if ((digit >= 'A') && (digit <= 'D')) {
617                 digit = digit - 'A' + 12;
618         } else if ((digit >= 'a') && (digit <= 'd')) {
619                 digit = digit - 'a' + 12;
620         } else {
621                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
622                 return -1;
623         }
624
625         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
626
627         /* Construct the packet we are going to send */
628         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
629         rtpheader[1] = htonl(rtp->lastdigitts);
630         rtpheader[2] = htonl(rtp->ssrc);
631         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
632         rtpheader[3] |= htonl((1 << 23));
633         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
634
635         /* Send it 3 times, that's the magical number */
636         for (i = 0; i < 3; i++) {
637                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &remote_address, sizeof(remote_address));
638                 if (res < 0) {
639                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
640                                 ast_inet_ntoa(remote_address.sin_addr),
641                                 ntohs(remote_address.sin_port), strerror(errno));
642                 }
643                 if (rtp_debug_test_addr(&remote_address)) {
644                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
645                                     ast_inet_ntoa(remote_address.sin_addr),
646                                     ntohs(remote_address.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
647                 }
648         }
649
650         /* Oh and we can't forget to turn off the stuff that says we are sending DTMF */
651         rtp->lastts += rtp->send_duration;
652         rtp->sending_digit = 0;
653         rtp->send_digit = 0;
654
655         return 0;
656 }
657
658 static void ast_rtp_new_source(struct ast_rtp_instance *instance)
659 {
660         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
661
662         /* We simply set this bit so that the next packet sent will have the marker bit turned on */
663         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
664
665         if (!ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_CONSTANT_SSRC)) {
666                 rtp->ssrc = ast_random();
667         }
668
669         return;
670 }
671
672 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
673 {
674         struct timeval t;
675         long ms;
676
677         if (ast_tvzero(rtp->txcore)) {
678                 rtp->txcore = ast_tvnow();
679                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
680         }
681
682         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
683         if ((ms = ast_tvdiff_ms(t, rtp->txcore)) < 0) {
684                 ms = 0;
685         }
686         rtp->txcore = t;
687
688         return (unsigned int) ms;
689 }
690
691 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
692 {
693         unsigned int sec, usec, frac;
694         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
695         usec = tv.tv_usec;
696         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
697         *msw = sec;
698         *lsw = frac;
699 }
700
701 /*! \brief Send RTCP recipient's report */
702 static int ast_rtcp_write_rr(const void *data)
703 {
704         struct ast_rtp *rtp = (struct ast_rtp *)data;
705         int res;
706         int len = 32;
707         unsigned int lost;
708         unsigned int extended;
709         unsigned int expected;
710         unsigned int expected_interval;
711         unsigned int received_interval;
712         int lost_interval;
713         struct timeval now;
714         unsigned int *rtcpheader;
715         char bdata[1024];
716         struct timeval dlsr;
717         int fraction;
718
719         double rxlost_current;
720
721         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
722                 return 0;
723
724         if (!rtp->rtcp->them.sin_addr.s_addr) {
725                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
726                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
727                 return 0;
728         }
729
730         extended = rtp->cycles + rtp->lastrxseqno;
731         expected = extended - rtp->seedrxseqno + 1;
732         lost = expected - rtp->rxcount;
733         expected_interval = expected - rtp->rtcp->expected_prior;
734         rtp->rtcp->expected_prior = expected;
735         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
736         rtp->rtcp->received_prior = rtp->rxcount;
737         lost_interval = expected_interval - received_interval;
738
739         if (lost_interval <= 0)
740                 rtp->rtcp->rxlost = 0;
741         else rtp->rtcp->rxlost = rtp->rtcp->rxlost;
742         if (rtp->rtcp->rxlost_count == 0)
743                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
744         if (lost_interval < rtp->rtcp->minrxlost)
745                 rtp->rtcp->minrxlost = rtp->rtcp->rxlost;
746         if (lost_interval > rtp->rtcp->maxrxlost)
747                 rtp->rtcp->maxrxlost = rtp->rtcp->rxlost;
748
749         rxlost_current = normdev_compute(rtp->rtcp->normdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->rxlost_count);
750         rtp->rtcp->stdev_rxlost = stddev_compute(rtp->rtcp->stdev_rxlost, rtp->rtcp->rxlost, rtp->rtcp->normdev_rxlost, rxlost_current, rtp->rtcp->rxlost_count);
751         rtp->rtcp->normdev_rxlost = rxlost_current;
752         rtp->rtcp->rxlost_count++;
753
754         if (expected_interval == 0 || lost_interval <= 0)
755                 fraction = 0;
756         else
757                 fraction = (lost_interval << 8) / expected_interval;
758         gettimeofday(&now, NULL);
759         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
760         rtcpheader = (unsigned int *)bdata;
761         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
762         rtcpheader[1] = htonl(rtp->ssrc);
763         rtcpheader[2] = htonl(rtp->themssrc);
764         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
765         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
766         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
767         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
768         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
769
770         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
771           it can change mid call, and SDES can't) */
772         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
773         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
774         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
775         len += 12;
776
777         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
778
779         if (res < 0) {
780                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
781                 /* Remove the scheduler */
782                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
783                 return 0;
784         }
785
786         rtp->rtcp->rr_count++;
787         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
788                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
789                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
790                         "  IA jitter: %.4f\n"
791                         "  Their last SR: %u\n"
792                             "  DLSR: %4.4f (sec)\n\n",
793                             ast_inet_ntoa(rtp->rtcp->them.sin_addr),
794                             ntohs(rtp->rtcp->them.sin_port),
795                             rtp->ssrc, rtp->themssrc, fraction, lost,
796                             rtp->rxjitter,
797                             rtp->rtcp->themrxlsr,
798                             (double)(ntohl(rtcpheader[7])/65536.0));
799         }
800
801         return res;
802 }
803
804 /*! \brief Send RTCP sender's report */
805 static int ast_rtcp_write_sr(const void *data)
806 {
807         struct ast_rtp *rtp = (struct ast_rtp *)data;
808         int res;
809         int len = 0;
810         struct timeval now;
811         unsigned int now_lsw;
812         unsigned int now_msw;
813         unsigned int *rtcpheader;
814         unsigned int lost;
815         unsigned int extended;
816         unsigned int expected;
817         unsigned int expected_interval;
818         unsigned int received_interval;
819         int lost_interval;
820         int fraction;
821         struct timeval dlsr;
822         char bdata[512];
823
824         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
825         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
826                 return 0;
827
828         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
829                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
830                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
831                 return 0;
832         }
833
834         gettimeofday(&now, NULL);
835         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
836         rtcpheader = (unsigned int *)bdata;
837         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
838         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
839         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
840         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
841         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
842         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
843         len += 28;
844
845         extended = rtp->cycles + rtp->lastrxseqno;
846         expected = extended - rtp->seedrxseqno + 1;
847         if (rtp->rxcount > expected)
848                 expected += rtp->rxcount - expected;
849         lost = expected - rtp->rxcount;
850         expected_interval = expected - rtp->rtcp->expected_prior;
851         rtp->rtcp->expected_prior = expected;
852         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
853         rtp->rtcp->received_prior = rtp->rxcount;
854         lost_interval = expected_interval - received_interval;
855         if (expected_interval == 0 || lost_interval <= 0)
856                 fraction = 0;
857         else
858                 fraction = (lost_interval << 8) / expected_interval;
859         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
860         rtcpheader[7] = htonl(rtp->themssrc);
861         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
862         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
863         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
864         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
865         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
866         len += 24;
867
868         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
869
870         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
871         /* it can change mid call, and SDES can't) */
872         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
873         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
874         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
875         len += 12;
876
877         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
878         if (res < 0) {
879                 ast_log(LOG_ERROR, "RTCP SR transmission error to %s:%d, rtcp halted %s\n",ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), strerror(errno));
880                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
881                 return 0;
882         }
883
884         /* FIXME Don't need to get a new one */
885         gettimeofday(&rtp->rtcp->txlsr, NULL);
886         rtp->rtcp->sr_count++;
887
888         rtp->rtcp->lastsrtxcount = rtp->txcount;
889
890         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
891                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
892                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
893                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
894                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
895                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
896                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
897                 ast_verbose("  Report block:\n");
898                 ast_verbose("  Fraction lost: %u\n", fraction);
899                 ast_verbose("  Cumulative loss: %u\n", lost);
900                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
901                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
902                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
903         }
904         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
905                                             "OurSSRC: %u\r\n"
906                                             "SentNTP: %u.%010u\r\n"
907                                             "SentRTP: %u\r\n"
908                                             "SentPackets: %u\r\n"
909                                             "SentOctets: %u\r\n"
910                                             "ReportBlock:\r\n"
911                                             "FractionLost: %u\r\n"
912                                             "CumulativeLoss: %u\r\n"
913                                             "IAJitter: %.4f\r\n"
914                                             "TheirLastSR: %u\r\n"
915                       "DLSR: %4.4f (sec)\r\n",
916                       ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
917                       rtp->ssrc,
918                       (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
919                       rtp->lastts,
920                       rtp->txcount,
921                       rtp->txoctetcount,
922                       fraction,
923                       lost,
924                       rtp->rxjitter,
925                       rtp->rtcp->themrxlsr,
926                       (double)(ntohl(rtcpheader[12])/65536.0));
927         return res;
928 }
929
930 /*! \brief Write and RTCP packet to the far end
931  * \note Decide if we are going to send an SR (with Reception Block) or RR
932  * RR is sent if we have not sent any rtp packets in the previous interval */
933 static int ast_rtcp_write(const void *data)
934 {
935         struct ast_rtp *rtp = (struct ast_rtp *)data;
936         int res;
937
938         if (!rtp || !rtp->rtcp)
939                 return 0;
940
941         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
942                 res = ast_rtcp_write_sr(data);
943         else
944                 res = ast_rtcp_write_rr(data);
945
946         return res;
947 }
948
949 static int ast_rtp_raw_write(struct ast_rtp_instance *instance, struct ast_frame *frame, int codec)
950 {
951         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
952         int pred, mark = 0;
953         unsigned int ms = calc_txstamp(rtp, &frame->delivery);
954         struct sockaddr_in remote_address = { 0, };
955         int rate = rtp_get_rate(frame->subclass.codec) / 1000;
956
957         if (frame->subclass.codec == AST_FORMAT_G722) {
958                 frame->samples /= 2;
959         }
960
961         if (rtp->sending_digit) {
962                 return 0;
963         }
964
965         if (frame->frametype == AST_FRAME_VOICE) {
966                 pred = rtp->lastts + frame->samples;
967
968                 /* Re-calculate last TS */
969                 rtp->lastts = rtp->lastts + ms * rate;
970                 if (ast_tvzero(frame->delivery)) {
971                         /* If this isn't an absolute delivery time, Check if it is close to our prediction,
972                            and if so, go with our prediction */
973                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) {
974                                 rtp->lastts = pred;
975                         } else {
976                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
977                                 mark = 1;
978                         }
979                 }
980         } else if (frame->frametype == AST_FRAME_VIDEO) {
981                 mark = frame->subclass.codec & 0x1;
982                 pred = rtp->lastovidtimestamp + frame->samples;
983                 /* Re-calculate last TS */
984                 rtp->lastts = rtp->lastts + ms * 90;
985                 /* If it's close to our prediction, go for it */
986                 if (ast_tvzero(frame->delivery)) {
987                         if (abs(rtp->lastts - pred) < 7200) {
988                                 rtp->lastts = pred;
989                                 rtp->lastovidtimestamp += frame->samples;
990                         } else {
991                                 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);
992                                 rtp->lastovidtimestamp = rtp->lastts;
993                         }
994                 }
995         } else {
996                 pred = rtp->lastotexttimestamp + frame->samples;
997                 /* Re-calculate last TS */
998                 rtp->lastts = rtp->lastts + ms;
999                 /* If it's close to our prediction, go for it */
1000                 if (ast_tvzero(frame->delivery)) {
1001                         if (abs(rtp->lastts - pred) < 7200) {
1002                                 rtp->lastts = pred;
1003                                 rtp->lastotexttimestamp += frame->samples;
1004                         } else {
1005                                 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);
1006                                 rtp->lastotexttimestamp = rtp->lastts;
1007                         }
1008                 }
1009         }
1010
1011         /* If we have been explicitly told to set the marker bit then do so */
1012         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1013                 mark = 1;
1014                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1015         }
1016
1017         /* If the timestamp for non-digt packets has moved beyond the timestamp for digits, update the digit timestamp */
1018         if (rtp->lastts > rtp->lastdigitts) {
1019                 rtp->lastdigitts = rtp->lastts;
1020         }
1021
1022         if (ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
1023                 rtp->lastts = frame->ts * rate;
1024         }
1025
1026         ast_rtp_instance_get_remote_address(instance, &remote_address);
1027
1028         /* If we know the remote address construct a packet and send it out */
1029         if (remote_address.sin_port && remote_address.sin_addr.s_addr) {
1030                 int hdrlen = 12, res;
1031                 unsigned char *rtpheader = (unsigned char *)(frame->data.ptr - hdrlen);
1032
1033                 put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1034                 put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1035                 put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
1036
1037                 if ((res = sendto(rtp->s, (void *)rtpheader, frame->datalen + hdrlen, 0, (struct sockaddr *)&remote_address, sizeof(remote_address))) < 0) {
1038                         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))) {
1039                                 ast_debug(1, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
1040                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
1041                                 /* Only give this error message once if we are not RTP debugging */
1042                                 if (option_debug || rtpdebug)
1043                                         ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1044                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1045                         }
1046                 } else {
1047                         rtp->txcount++;
1048                         rtp->txoctetcount += (res - hdrlen);
1049
1050                         if (rtp->rtcp && rtp->rtcp->schedid < 1) {
1051                                 ast_debug(1, "Starting RTCP transmission on RTP instance '%p'\n", instance);
1052                                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1053                         }
1054                 }
1055
1056                 if (rtp_debug_test_addr(&remote_address)) {
1057                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1058                                     ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), codec, rtp->seqno, rtp->lastts, res - hdrlen);
1059                 }
1060         }
1061
1062         rtp->seqno++;
1063
1064         return 0;
1065 }
1066
1067 static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
1068         unsigned char *data = red->t140red.data.ptr;
1069         int len = 0;
1070         int i;
1071
1072         /* replace most aged generation */
1073         if (red->len[0]) {
1074                 for (i = 1; i < red->num_gen+1; i++)
1075                         len += red->len[i];
1076
1077                 memmove(&data[red->hdrlen], &data[red->hdrlen+red->len[0]], len);
1078         }
1079
1080         /* Store length of each generation and primary data length*/
1081         for (i = 0; i < red->num_gen; i++)
1082                 red->len[i] = red->len[i+1];
1083         red->len[i] = red->t140.datalen;
1084
1085         /* write each generation length in red header */
1086         len = red->hdrlen;
1087         for (i = 0; i < red->num_gen; i++)
1088                 len += data[i*4+3] = red->len[i];
1089
1090         /* add primary data to buffer */
1091         memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
1092         red->t140red.datalen = len + red->t140.datalen;
1093
1094         /* no primary data and no generations to send */
1095         if (len == red->hdrlen && !red->t140.datalen)
1096                 return NULL;
1097
1098         /* reset t.140 buffer */
1099         red->t140.datalen = 0;
1100
1101         return &red->t140red;
1102 }
1103
1104 static int ast_rtp_write(struct ast_rtp_instance *instance, struct ast_frame *frame)
1105 {
1106         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1107         struct sockaddr_in remote_address = { 0, };
1108         format_t codec, subclass;
1109
1110         ast_rtp_instance_get_remote_address(instance, &remote_address);
1111
1112         /* If we don't actually know the remote address don't even bother doing anything */
1113         if (!remote_address.sin_addr.s_addr) {
1114                 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
1115                 return 0;
1116         }
1117
1118         /* If there is no data length we can't very well send the packet */
1119         if (!frame->datalen) {
1120                 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
1121                 return 0;
1122         }
1123
1124         /* If the packet is not one our RTP stack supports bail out */
1125         if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
1126                 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
1127                 return -1;
1128         }
1129
1130         if (rtp->red) {
1131                 /* return 0; */
1132                 /* no primary data or generations to send */
1133                 if ((frame = red_t140_to_red(rtp->red)) == NULL)
1134                         return 0;
1135         }
1136
1137         /* Grab the subclass and look up the payload we are going to use */
1138         subclass = frame->subclass.codec;
1139         if (frame->frametype == AST_FRAME_VIDEO) {
1140                 subclass &= ~0x1LL;
1141         }
1142         if ((codec = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 1, subclass)) < 0) {
1143                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(frame->subclass.codec));
1144                 return -1;
1145         }
1146
1147         /* Oh dear, if the format changed we will have to set up a new smoother */
1148         if (rtp->lasttxformat != subclass) {
1149                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1150                 rtp->lasttxformat = subclass;
1151                 if (rtp->smoother) {
1152                         ast_smoother_free(rtp->smoother);
1153                         rtp->smoother = NULL;
1154                 }
1155         }
1156
1157         /* If no smoother is present see if we have to set one up */
1158         if (!rtp->smoother) {
1159                 struct ast_format_list fmt = ast_codec_pref_getsize(&ast_rtp_instance_get_codecs(instance)->pref, subclass);
1160
1161                 switch (subclass) {
1162                 case AST_FORMAT_SPEEX:
1163                 case AST_FORMAT_G723_1:
1164                 case AST_FORMAT_SIREN7:
1165                 case AST_FORMAT_SIREN14:
1166                         /* these are all frame-based codecs and cannot be safely run through
1167                            a smoother */
1168                         break;
1169                 default:
1170                         if (fmt.inc_ms) {
1171                                 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
1172                                         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));
1173                                         return -1;
1174                                 }
1175                                 if (fmt.flags) {
1176                                         ast_smoother_set_flags(rtp->smoother, fmt.flags);
1177                                 }
1178                                 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));
1179                         }
1180                 }
1181         }
1182
1183         /* Feed audio frames into the actual function that will create a frame and send it */
1184         if (rtp->smoother) {
1185                 struct ast_frame *f;
1186
1187                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
1188                         ast_smoother_feed_be(rtp->smoother, frame);
1189                 } else {
1190                         ast_smoother_feed(rtp->smoother, frame);
1191                 }
1192
1193                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
1194                                 ast_rtp_raw_write(instance, f, codec);
1195                 }
1196         } else {
1197                 int hdrlen = 12;
1198                 struct ast_frame *f = NULL;
1199
1200                 if (frame->offset < hdrlen) {
1201                         f = ast_frdup(frame);
1202                 } else {
1203                         f = frame;
1204                 }
1205                 if (f->data.ptr) {
1206                         ast_rtp_raw_write(instance, f, codec);
1207                 }
1208                 if (f != frame) {
1209                         ast_frfree(f);
1210                 }
1211
1212         }
1213
1214         return 0;
1215 }
1216
1217 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1218 {
1219         struct timeval now;
1220         struct timeval tmp;
1221         double transit;
1222         double current_time;
1223         double d;
1224         double dtv;
1225         double prog;
1226         int rate = rtp_get_rate(rtp->f.subclass.codec);
1227
1228         double normdev_rxjitter_current;
1229         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1230                 gettimeofday(&rtp->rxcore, NULL);
1231                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1232                 /* map timestamp to a real time */
1233                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1234                 tmp = ast_samp2tv(timestamp, rate);
1235                 rtp->rxcore = ast_tvsub(rtp->rxcore, tmp);
1236                 /* Round to 0.1ms for nice, pretty timestamps */
1237                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1238         }
1239
1240         gettimeofday(&now,NULL);
1241         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1242         tmp = ast_samp2tv(timestamp, rate);
1243         *tv = ast_tvadd(rtp->rxcore, tmp);
1244
1245         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
1246         dtv = (double)rtp->drxcore + (double)(prog);
1247         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1248         transit = current_time - dtv;
1249         d = transit - rtp->rxtransit;
1250         rtp->rxtransit = transit;
1251         if (d<0)
1252                 d=-d;
1253         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1254
1255         if (rtp->rtcp) {
1256                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
1257                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
1258                 if (rtp->rtcp->rxjitter_count == 1)
1259                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1260                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1261                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1262
1263                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
1264                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
1265
1266                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
1267                 rtp->rtcp->rxjitter_count++;
1268         }
1269 }
1270
1271 static struct ast_frame *send_dtmf(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
1272 {
1273         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1274         struct sockaddr_in remote_address = { 0, };
1275
1276         ast_rtp_instance_get_remote_address(instance, &remote_address);
1277
1278         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
1279                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(remote_address.sin_addr));
1280                 rtp->resp = 0;
1281                 rtp->dtmfsamples = 0;
1282                 return &ast_null_frame;
1283         }
1284         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(remote_address.sin_addr));
1285         if (rtp->resp == 'X') {
1286                 rtp->f.frametype = AST_FRAME_CONTROL;
1287                 rtp->f.subclass.integer = AST_CONTROL_FLASH;
1288         } else {
1289                 rtp->f.frametype = type;
1290                 rtp->f.subclass.integer = rtp->resp;
1291         }
1292         rtp->f.datalen = 0;
1293         rtp->f.samples = 0;
1294         rtp->f.mallocd = 0;
1295         rtp->f.src = "RTP";
1296
1297         return &rtp->f;
1298 }
1299
1300 static struct ast_frame *process_dtmf_rfc2833(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1301 {
1302         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1303         struct sockaddr_in remote_address = { 0, };
1304         unsigned int event, event_end, samples;
1305         char resp = 0;
1306         struct ast_frame *f = NULL;
1307
1308         ast_rtp_instance_get_remote_address(instance, &remote_address);
1309
1310         /* Figure out event, event end, and samples */
1311         event = ntohl(*((unsigned int *)(data)));
1312         event >>= 24;
1313         event_end = ntohl(*((unsigned int *)(data)));
1314         event_end <<= 8;
1315         event_end >>= 24;
1316         samples = ntohl(*((unsigned int *)(data)));
1317         samples &= 0xFFFF;
1318
1319         if (rtp_debug_test_addr(&remote_address)) {
1320                 ast_verbose("Got  RTP RFC2833 from   %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(remote_address.sin_addr),
1321                             ntohs(remote_address.sin_port), payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
1322         }
1323
1324         /* Print out debug if turned on */
1325         if (rtpdebug || option_debug > 2)
1326                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
1327
1328         /* Figure out what digit was pressed */
1329         if (event < 10) {
1330                 resp = '0' + event;
1331         } else if (event < 11) {
1332                 resp = '*';
1333         } else if (event < 12) {
1334                 resp = '#';
1335         } else if (event < 16) {
1336                 resp = 'A' + (event - 12);
1337         } else if (event < 17) {        /* Event 16: Hook flash */
1338                 resp = 'X';
1339         } else {
1340                 /* Not a supported event */
1341                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
1342                 return &ast_null_frame;
1343         }
1344
1345         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1346                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
1347                         rtp->resp = resp;
1348                         rtp->dtmf_timeout = 0;
1349                         f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1350                         f->len = 0;
1351                         rtp->lastevent = timestamp;
1352                 }
1353         } else {
1354                 /*  The duration parameter measures the complete
1355                     duration of the event (from the beginning) - RFC2833.
1356                     Account for the fact that duration is only 16 bits long
1357                     (about 8 seconds at 8000 Hz) and can wrap is digit
1358                     is hold for too long. */
1359                 unsigned int new_duration = rtp->dtmf_duration;
1360                 unsigned int last_duration = new_duration & 0xFFFF;
1361
1362                 if (last_duration > 64000 && samples < last_duration) {
1363                         new_duration += 0xFFFF + 1;
1364                 }
1365                 new_duration = (new_duration & ~0xFFFF) | samples;
1366
1367                 if (event_end & 0x80) {
1368                         /* End event */
1369                         if ((rtp->lastevent != seqno) && rtp->resp) {
1370                                 rtp->dtmf_duration = new_duration;
1371                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1372                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
1373                                 rtp->resp = 0;
1374                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1375                         }
1376                 } else {
1377                         /* Begin/continuation */
1378
1379                         if (rtp->resp && rtp->resp != resp) {
1380                                 /* Another digit already began. End it */
1381                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1382                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
1383                                 rtp->resp = 0;
1384                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1385                         }
1386
1387                         if (rtp->resp) {
1388                                 /* Digit continues */
1389                                 rtp->dtmf_duration = new_duration;
1390                         } else {
1391                                 /* New digit began */
1392                                 rtp->resp = resp;
1393                                 f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1394                                 rtp->dtmf_duration = samples;
1395                         }
1396
1397                         rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
1398                 }
1399
1400                 rtp->lastevent = seqno;
1401         }
1402
1403         rtp->dtmfsamples = samples;
1404
1405         return f;
1406 }
1407
1408 static struct ast_frame *process_dtmf_cisco(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1409 {
1410         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1411         unsigned int event, flags, power;
1412         char resp = 0;
1413         unsigned char seq;
1414         struct ast_frame *f = NULL;
1415
1416         if (len < 4) {
1417                 return NULL;
1418         }
1419
1420         /*      The format of Cisco RTP DTMF packet looks like next:
1421                 +0                              - sequence number of DTMF RTP packet (begins from 1,
1422                                                   wrapped to 0)
1423                 +1                              - set of flags
1424                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
1425                                                   or repeated digit without audio???
1426                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
1427                                                   then falls to 0 at its end)
1428                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
1429                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
1430                 by each new packet and thus provides some redudancy.
1431
1432                 Sample of Cisco RTP DTMF packet is (all data in hex):
1433                         19 07 00 02 12 02 20 02
1434                 showing end of DTMF digit '2'.
1435
1436                 The packets
1437                         27 07 00 02 0A 02 20 02
1438                         28 06 20 02 00 02 0A 02
1439                 shows begin of new digit '2' with very short pause (20 ms) after
1440                 previous digit '2'. Bit +1.0 flips at begin of new digit.
1441
1442                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
1443                 so its uses the same sequencing and timestamping rules as replaced
1444                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
1445                 on audio framing parameters. Marker bit isn't used within stream of
1446                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
1447                 are not sequential at borders between DTMF and audio streams,
1448         */
1449
1450         seq = data[0];
1451         flags = data[1];
1452         power = data[2];
1453         event = data[3] & 0x1f;
1454
1455         if (option_debug > 2 || rtpdebug)
1456                 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);
1457         if (event < 10) {
1458                 resp = '0' + event;
1459         } else if (event < 11) {
1460                 resp = '*';
1461         } else if (event < 12) {
1462                 resp = '#';
1463         } else if (event < 16) {
1464                 resp = 'A' + (event - 12);
1465         } else if (event < 17) {
1466                 resp = 'X';
1467         }
1468         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
1469                 rtp->resp = resp;
1470                 /* Why we should care on DTMF compensation at reception? */
1471                 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1472                         f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1473                         rtp->dtmfsamples = 0;
1474                 }
1475         } else if ((rtp->resp == resp) && !power) {
1476                 f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1477                 f->samples = rtp->dtmfsamples * (rtp_get_rate(f->subclass.codec) / 1000);
1478                 rtp->resp = 0;
1479         } else if (rtp->resp == resp)
1480                 rtp->dtmfsamples += 20 * (rtp_get_rate(f->subclass.codec) / 1000);
1481         rtp->dtmf_timeout = 0;
1482
1483         return f;
1484 }
1485
1486 static struct ast_frame *process_cn_rfc3389(struct ast_rtp_instance *instance, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp, struct sockaddr_in *sin, int payloadtype, int mark)
1487 {
1488         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1489
1490         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1491            totally help us out becuase we don't have an engine to keep it going and we are not
1492            guaranteed to have it every 20ms or anything */
1493         if (rtpdebug)
1494                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %" PRId64 " (len = %d)\n", rtp->lastrxformat, len);
1495
1496         if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
1497                 struct sockaddr_in remote_address = { 0, };
1498
1499                 ast_rtp_instance_get_remote_address(instance, &remote_address);
1500
1501                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1502                         ast_inet_ntoa(remote_address.sin_addr));
1503                 ast_set_flag(rtp, FLAG_3389_WARNING);
1504         }
1505
1506         /* Must have at least one byte */
1507         if (!len)
1508                 return NULL;
1509         if (len < 24) {
1510                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
1511                 rtp->f.datalen = len - 1;
1512                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1513                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
1514         } else {
1515                 rtp->f.data.ptr = NULL;
1516                 rtp->f.offset = 0;
1517                 rtp->f.datalen = 0;
1518         }
1519         rtp->f.frametype = AST_FRAME_CNG;
1520         rtp->f.subclass.integer = data[0] & 0x7f;
1521         rtp->f.samples = 0;
1522         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1523
1524         return &rtp->f;
1525 }
1526
1527 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
1528 {
1529         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1530         struct sockaddr_in sin;
1531         socklen_t len = sizeof(sin);
1532         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1533         unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1534         int res, packetwords, position = 0;
1535         struct ast_frame *f = &ast_null_frame;
1536
1537         /* Read in RTCP data from the socket */
1538         if ((res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0) {
1539                 ast_assert(errno != EBADF);
1540                 if (errno != EAGAIN) {
1541                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1542                         return NULL;
1543                 }
1544                 return &ast_null_frame;
1545         }
1546
1547         packetwords = res / 4;
1548
1549         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1550                 /* Send to whoever sent to us */
1551                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1552                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
1553                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1554                         if (option_debug || rtpdebug)
1555                                 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1556                 }
1557         }
1558
1559         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1560
1561         while (position < packetwords) {
1562                 int i, pt, rc;
1563                 unsigned int length, dlsr, lsr, msw, lsw, comp;
1564                 struct timeval now;
1565                 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
1566                 uint64_t rtt = 0;
1567
1568                 i = position;
1569                 length = ntohl(rtcpheader[i]);
1570                 pt = (length & 0xff0000) >> 16;
1571                 rc = (length & 0x1f000000) >> 24;
1572                 length &= 0xffff;
1573
1574                 if ((i + length) > packetwords) {
1575                         if (option_debug || rtpdebug)
1576                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1577                         return &ast_null_frame;
1578                 }
1579
1580                 if (rtcp_debug_test_addr(&sin)) {
1581                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1582                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1583                         ast_verbose("Reception reports: %d\n", rc);
1584                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1585                 }
1586
1587                 i += 2; /* Advance past header and ssrc */
1588
1589                 switch (pt) {
1590                 case RTCP_PT_SR:
1591                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1592                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1593                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1594                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1595
1596                         if (rtcp_debug_test_addr(&sin)) {
1597                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1598                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1599                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1600                         }
1601                         i += 5;
1602                         if (rc < 1)
1603                                 break;
1604                         /* Intentional fall through */
1605                 case RTCP_PT_RR:
1606                         /* Don't handle multiple reception reports (rc > 1) yet */
1607                         /* Calculate RTT per RFC */
1608                         gettimeofday(&now, NULL);
1609                         timeval2ntp(now, &msw, &lsw);
1610                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1611                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1612                                 lsr = ntohl(rtcpheader[i + 4]);
1613                                 dlsr = ntohl(rtcpheader[i + 5]);
1614                                 rtt = comp - lsr - dlsr;
1615
1616                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1617                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1618                                 if (rtt < 4294) {
1619                                         rtt = (rtt * 1000000) >> 16;
1620                                 } else {
1621                                         rtt = (rtt * 1000) >> 16;
1622                                         rtt *= 1000;
1623                                 }
1624                                 rtt = rtt / 1000.;
1625                                 rttsec = rtt / 1000.;
1626                                 rtp->rtcp->rtt = rttsec;
1627
1628                                 if (comp - dlsr >= lsr) {
1629                                         rtp->rtcp->accumulated_transit += rttsec;
1630
1631                                         if (rtp->rtcp->rtt_count == 0)
1632                                                 rtp->rtcp->minrtt = rttsec;
1633
1634                                         if (rtp->rtcp->maxrtt<rttsec)
1635                                                 rtp->rtcp->maxrtt = rttsec;
1636                                         if (rtp->rtcp->minrtt>rttsec)
1637                                                 rtp->rtcp->minrtt = rttsec;
1638
1639                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
1640
1641                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
1642
1643                                         rtp->rtcp->normdevrtt = normdevrtt_current;
1644
1645                                         rtp->rtcp->rtt_count++;
1646                                 } else if (rtcp_debug_test_addr(&sin)) {
1647                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1648                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1649                                                     "diff=%d\n",
1650                                                     lsr, comp, dlsr, dlsr / 65536,
1651                                                     (dlsr % 65536) * 1000 / 65536,
1652                                                     dlsr - (comp - lsr));
1653                                 }
1654                         }
1655
1656                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1657                         reported_jitter = (double) rtp->rtcp->reported_jitter;
1658
1659                         if (rtp->rtcp->reported_jitter_count == 0)
1660                                 rtp->rtcp->reported_minjitter = reported_jitter;
1661
1662                         if (reported_jitter < rtp->rtcp->reported_minjitter)
1663                                 rtp->rtcp->reported_minjitter = reported_jitter;
1664
1665                         if (reported_jitter > rtp->rtcp->reported_maxjitter)
1666                                 rtp->rtcp->reported_maxjitter = reported_jitter;
1667
1668                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
1669
1670                         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);
1671
1672                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
1673
1674                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1675
1676                         reported_lost = (double) rtp->rtcp->reported_lost;
1677
1678                         /* using same counter as for jitter */
1679                         if (rtp->rtcp->reported_jitter_count == 0)
1680                                 rtp->rtcp->reported_minlost = reported_lost;
1681
1682                         if (reported_lost < rtp->rtcp->reported_minlost)
1683                                 rtp->rtcp->reported_minlost = reported_lost;
1684
1685                         if (reported_lost > rtp->rtcp->reported_maxlost)
1686                                 rtp->rtcp->reported_maxlost = reported_lost;
1687                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
1688
1689                         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);
1690
1691                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
1692
1693                         rtp->rtcp->reported_jitter_count++;
1694
1695                         if (rtcp_debug_test_addr(&sin)) {
1696                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1697                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1698                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1699                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1700                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1701                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1702                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1703                                 if (rtt)
1704                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1705                         }
1706                         if (rtt) {
1707                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1708                                                                     "PT: %d(%s)\r\n"
1709                                                                     "ReceptionReports: %d\r\n"
1710                                                                     "SenderSSRC: %u\r\n"
1711                                                                     "FractionLost: %ld\r\n"
1712                                                                     "PacketsLost: %d\r\n"
1713                                                                     "HighestSequence: %ld\r\n"
1714                                                                     "SequenceNumberCycles: %ld\r\n"
1715                                                                     "IAJitter: %u\r\n"
1716                                                                     "LastSR: %lu.%010lu\r\n"
1717                                                                     "DLSR: %4.4f(sec)\r\n"
1718                                               "RTT: %llu(sec)\r\n",
1719                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1720                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1721                                               rc,
1722                                               rtcpheader[i + 1],
1723                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1724                                               rtp->rtcp->reported_lost,
1725                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1726                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1727                                               rtp->rtcp->reported_jitter,
1728                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1729                                               ntohl(rtcpheader[i + 5])/65536.0,
1730                                               (unsigned long long)rtt);
1731                         } else {
1732                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1733                                                                     "PT: %d(%s)\r\n"
1734                                                                     "ReceptionReports: %d\r\n"
1735                                                                     "SenderSSRC: %u\r\n"
1736                                                                     "FractionLost: %ld\r\n"
1737                                                                     "PacketsLost: %d\r\n"
1738                                                                     "HighestSequence: %ld\r\n"
1739                                                                     "SequenceNumberCycles: %ld\r\n"
1740                                                                     "IAJitter: %u\r\n"
1741                                                                     "LastSR: %lu.%010lu\r\n"
1742                                               "DLSR: %4.4f(sec)\r\n",
1743                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1744                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1745                                               rc,
1746                                               rtcpheader[i + 1],
1747                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1748                                               rtp->rtcp->reported_lost,
1749                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1750                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1751                                               rtp->rtcp->reported_jitter,
1752                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1753                                               ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1754                                               ntohl(rtcpheader[i + 5])/65536.0);
1755                         }
1756                         break;
1757                 case RTCP_PT_FUR:
1758                         if (rtcp_debug_test_addr(&sin))
1759                                 ast_verbose("Received an RTCP Fast Update Request\n");
1760                         rtp->f.frametype = AST_FRAME_CONTROL;
1761                         rtp->f.subclass.integer = AST_CONTROL_VIDUPDATE;
1762                         rtp->f.datalen = 0;
1763                         rtp->f.samples = 0;
1764                         rtp->f.mallocd = 0;
1765                         rtp->f.src = "RTP";
1766                         f = &rtp->f;
1767                         break;
1768                 case RTCP_PT_SDES:
1769                         if (rtcp_debug_test_addr(&sin))
1770                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1771                         break;
1772                 case RTCP_PT_BYE:
1773                         if (rtcp_debug_test_addr(&sin))
1774                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1775                         break;
1776                 default:
1777                         ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1778                         break;
1779                 }
1780                 position += (length + 1);
1781         }
1782
1783         rtp->rtcp->rtcp_info = 1;
1784
1785         return f;
1786 }
1787
1788 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
1789 {
1790         struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
1791         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
1792         int res = 0, payload = 0, bridged_payload = 0, mark;
1793         struct ast_rtp_payload_type payload_type;
1794         int reconstruct = ntohl(rtpheader[0]);
1795         struct sockaddr_in remote_address = { 0, };
1796
1797         /* Get fields from packet */
1798         payload = (reconstruct & 0x7f0000) >> 16;
1799         mark = (((reconstruct & 0x800000) >> 23) != 0);
1800
1801         /* Check what the payload value should be */
1802         payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
1803
1804         /* Otherwise adjust bridged payload to match */
1805         bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, payload_type.code);
1806
1807         /* 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 */
1808         if (!(ast_rtp_instance_get_codecs(instance1)->payloads[bridged_payload].code)) {
1809                 return -1;
1810         }
1811
1812         /* If the marker bit has been explicitly set turn it on */
1813         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1814                 mark = 1;
1815                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1816         }
1817
1818         /* Reconstruct part of the packet */
1819         reconstruct &= 0xFF80FFFF;
1820         reconstruct |= (bridged_payload << 16);
1821         reconstruct |= (mark << 23);
1822         rtpheader[0] = htonl(reconstruct);
1823
1824         ast_rtp_instance_get_remote_address(instance1, &remote_address);
1825
1826         /* Send the packet back out */
1827         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&remote_address, sizeof(remote_address));
1828         if (res < 0) {
1829                 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))) {
1830                         ast_debug(1, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), strerror(errno));
1831                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1832                         if (option_debug || rtpdebug)
1833                                 ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1834                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1835                 }
1836                 return 0;
1837         } else if (rtp_debug_test_addr(&remote_address)) {
1838                 ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port), bridged_payload, len - hdrlen);
1839         }
1840
1841         return 0;
1842 }
1843
1844 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
1845 {
1846         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1847         struct sockaddr_in sin;
1848         socklen_t len = sizeof(sin);
1849         int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
1850         unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
1851         struct ast_rtp_payload_type payload;
1852         struct sockaddr_in remote_address = { 0, };
1853
1854         /* If this is actually RTCP let's hop on over and handle it */
1855         if (rtcp) {
1856                 if (rtp->rtcp) {
1857                         return ast_rtcp_read(instance);
1858                 }
1859                 return &ast_null_frame;
1860         }
1861
1862         /* If we are currently sending DTMF to the remote party send a continuation packet */
1863         if (rtp->sending_digit) {
1864                 ast_rtp_dtmf_continuation(instance);
1865         }
1866
1867         /* Actually read in the data from the socket */
1868         if ((res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr*)&sin, &len)) < 0) {
1869                 ast_assert(errno != EBADF);
1870                 if (errno != EAGAIN) {
1871                         ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
1872                         return NULL;
1873                 }
1874                 return &ast_null_frame;
1875         }
1876
1877         /* Make sure the data that was read in is actually enough to make up an RTP packet */
1878         if (res < hdrlen) {
1879                 ast_log(LOG_WARNING, "RTP Read too short\n");
1880                 return &ast_null_frame;
1881         }
1882
1883         /* If strict RTP protection is enabled see if we need to learn the remote address or if we need to drop the packet */
1884         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
1885                 memcpy(&rtp->strict_rtp_address, &sin, sizeof(rtp->strict_rtp_address));
1886                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
1887         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
1888                 if ((rtp->strict_rtp_address.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->strict_rtp_address.sin_port != sin.sin_port)) {
1889                         /* Hmm, not the strict addres. Perhaps we're getting audio from the alternate? */
1890                         if ((rtp->alt_rtp_address.sin_addr.s_addr == sin.sin_addr.s_addr) && (rtp->alt_rtp_address.sin_port == sin.sin_port)) {
1891                                 /* ooh, we did! You're now the new expected address, son! */
1892                                 rtp->strict_rtp_address = sin;
1893                         } else  {
1894                                 ast_debug(1, "Received RTP packet from %s:%d, dropping due to strict RTP protection. Expected it to be from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), ast_inet_ntoa(rtp->strict_rtp_address.sin_addr), ntohs(rtp->strict_rtp_address.sin_port));
1895                                 return &ast_null_frame;
1896                         }
1897                 }
1898         }
1899
1900         /* Get fields and verify this is an RTP packet */
1901         seqno = ntohl(rtpheader[0]);
1902
1903         ast_rtp_instance_get_remote_address(instance, &remote_address);
1904
1905         if (!(version = (seqno & 0xC0000000) >> 30)) {
1906                 if ((ast_stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
1907                     (!remote_address.sin_port && !remote_address.sin_addr.s_addr)) {
1908                         ast_rtp_instance_set_remote_address(instance, &sin);
1909                 }
1910                 return &ast_null_frame;
1911         }
1912
1913         /* If symmetric RTP is enabled see if the remote side is not what we expected and change where we are sending audio */
1914         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1915                 if ((remote_address.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1916                     (remote_address.sin_port != sin.sin_port)) {
1917                         ast_rtp_instance_set_remote_address(instance, &sin);
1918                         memcpy(&remote_address, &sin, sizeof(remote_address));
1919                         if (rtp->rtcp) {
1920                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1921                                 rtp->rtcp->them.sin_port = htons(ntohs(sin.sin_port)+1);
1922                         }
1923                         rtp->rxseqno = 0;
1924                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1925                         if (option_debug || rtpdebug)
1926                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
1927                 }
1928         }
1929
1930         /* If we are directly bridged to another instance send the audio directly out */
1931         if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
1932                 return &ast_null_frame;
1933         }
1934
1935         /* If the version is not what we expected by this point then just drop the packet */
1936         if (version != 2) {
1937                 return &ast_null_frame;
1938         }
1939
1940         /* Pull out the various other fields we will need */
1941         payloadtype = (seqno & 0x7f0000) >> 16;
1942         padding = seqno & (1 << 29);
1943         mark = seqno & (1 << 23);
1944         ext = seqno & (1 << 28);
1945         cc = (seqno & 0xF000000) >> 24;
1946         seqno &= 0xffff;
1947         timestamp = ntohl(rtpheader[1]);
1948         ssrc = ntohl(rtpheader[2]);
1949
1950         /* Force a marker bit if the SSRC changes */
1951         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1952                 if (option_debug || rtpdebug) {
1953                         ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
1954                 }
1955                 mark = 1;
1956         }
1957
1958         /* Remove any padding bytes that may be present */
1959         if (padding) {
1960                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1961         }
1962
1963         /* Skip over any CSRC fields */
1964         if (cc) {
1965                 hdrlen += cc * 4;
1966         }
1967
1968         /* Look for any RTP extensions, currently we do not support any */
1969         if (ext) {
1970                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1971                 hdrlen += 4;
1972                 if (option_debug) {
1973                         int profile;
1974                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1975                         if (profile == 0x505a)
1976                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1977                         else
1978                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1979                 }
1980         }
1981
1982         /* Make sure after we potentially mucked with the header length that it is once again valid */
1983         if (res < hdrlen) {
1984                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
1985                 return &ast_null_frame;
1986         }
1987
1988         rtp->rxcount++;
1989         if (rtp->rxcount == 1) {
1990                 rtp->seedrxseqno = seqno;
1991         }
1992
1993         /* Do not schedule RR if RTCP isn't run */
1994         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1995                 /* Schedule transmission of Receiver Report */
1996                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1997         }
1998         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1999                 rtp->cycles += RTP_SEQ_MOD;
2000
2001         prev_seqno = rtp->lastrxseqno;
2002         rtp->lastrxseqno = seqno;
2003
2004         if (!rtp->themssrc) {
2005                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
2006         }
2007
2008         if (rtp_debug_test_addr(&sin)) {
2009                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2010                             ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
2011         }
2012
2013         payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
2014
2015         /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
2016         if (!payload.asterisk_format) {
2017                 struct ast_frame *f = NULL;
2018                 if (payload.code == AST_RTP_DTMF) {
2019                         f = process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2020                 } else if (payload.code == AST_RTP_CISCO_DTMF) {
2021                         f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2022                 } else if (payload.code == AST_RTP_CN) {
2023                         f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2024                 } else {
2025                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(remote_address.sin_addr));
2026                 }
2027
2028                 return f ? f : &ast_null_frame;
2029         }
2030
2031         rtp->lastrxformat = rtp->f.subclass.codec = payload.code;
2032         rtp->f.frametype = (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
2033
2034         rtp->rxseqno = seqno;
2035
2036         if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
2037                 rtp->dtmf_timeout = 0;
2038
2039                 if (rtp->resp) {
2040                         struct ast_frame *f;
2041                         f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
2042                         f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
2043                         rtp->resp = 0;
2044                         rtp->dtmf_timeout = rtp->dtmf_duration = 0;
2045                         return f;
2046                 }
2047         }
2048
2049         rtp->lastrxts = timestamp;
2050
2051         rtp->f.src = "RTP";
2052         rtp->f.mallocd = 0;
2053         rtp->f.datalen = res - hdrlen;
2054         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
2055         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
2056         rtp->f.seqno = seqno;
2057
2058         if (rtp->f.subclass.codec == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
2059                 unsigned char *data = rtp->f.data.ptr;
2060
2061                 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
2062                 rtp->f.datalen +=3;
2063                 *data++ = 0xEF;
2064                 *data++ = 0xBF;
2065                 *data = 0xBD;
2066         }
2067
2068         if (rtp->f.subclass.codec == AST_FORMAT_T140RED) {
2069                 unsigned char *data = rtp->f.data.ptr;
2070                 unsigned char *header_end;
2071                 int num_generations;
2072                 int header_length;
2073                 int len;
2074                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
2075                 int x;
2076
2077                 rtp->f.subclass.codec = AST_FORMAT_T140;
2078                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
2079                 if (header_end == NULL) {
2080                         return &ast_null_frame;
2081                 }
2082                 header_end++;
2083
2084                 header_length = header_end - data;
2085                 num_generations = header_length / 4;
2086                 len = header_length;
2087
2088                 if (!diff) {
2089                         for (x = 0; x < num_generations; x++)
2090                                 len += data[x * 4 + 3];
2091
2092                         if (!(rtp->f.datalen - len))
2093                                 return &ast_null_frame;
2094
2095                         rtp->f.data.ptr += len;
2096                         rtp->f.datalen -= len;
2097                 } else if (diff > num_generations && diff < 10) {
2098                         len -= 3;
2099                         rtp->f.data.ptr += len;
2100                         rtp->f.datalen -= len;
2101
2102                         data = rtp->f.data.ptr;
2103                         *data++ = 0xEF;
2104                         *data++ = 0xBF;
2105                         *data = 0xBD;
2106                 } else {
2107                         for ( x = 0; x < num_generations - diff; x++)
2108                                 len += data[x * 4 + 3];
2109
2110                         rtp->f.data.ptr += len;
2111                         rtp->f.datalen -= len;
2112                 }
2113         }
2114
2115         if (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) {
2116                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
2117                 if (rtp->f.subclass.codec == AST_FORMAT_SLINEAR)
2118                         ast_frame_byteswap_be(&rtp->f);
2119                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
2120                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
2121                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
2122                 rtp->f.ts = timestamp / (rtp_get_rate(rtp->f.subclass.codec) / 1000);
2123                 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass.codec) / 1000));
2124         } else if (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) {
2125                 /* Video -- samples is # of samples vs. 90000 */
2126                 if (!rtp->lastividtimestamp)
2127                         rtp->lastividtimestamp = timestamp;
2128                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
2129                 rtp->lastividtimestamp = timestamp;
2130                 rtp->f.delivery.tv_sec = 0;
2131                 rtp->f.delivery.tv_usec = 0;
2132                 /* Pass the RTP marker bit as bit 0 in the subclass field.
2133                  * This is ok because subclass is actually a bitmask, and
2134                  * the low bits represent audio formats, that are not
2135                  * involved here since we deal with video.
2136                  */
2137                 if (mark)
2138                         rtp->f.subclass.codec |= 0x1;
2139         } else {
2140                 /* TEXT -- samples is # of samples vs. 1000 */
2141                 if (!rtp->lastitexttimestamp)
2142                         rtp->lastitexttimestamp = timestamp;
2143                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
2144                 rtp->lastitexttimestamp = timestamp;
2145                 rtp->f.delivery.tv_sec = 0;
2146                 rtp->f.delivery.tv_usec = 0;
2147         }
2148
2149         return &rtp->f;
2150 }
2151
2152 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
2153 {
2154         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2155
2156         if (property == AST_RTP_PROPERTY_RTCP) {
2157                 if (rtp->rtcp) {
2158                         ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
2159                         return;
2160                 }
2161                 if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
2162                         return;
2163                 }
2164                 if ((rtp->rtcp->s = create_new_socket("RTCP")) < 0) {
2165                         ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
2166                         ast_free(rtp->rtcp);
2167                         rtp->rtcp = NULL;
2168                         return;
2169                 }
2170
2171                 /* Grab the IP address and port we are going to use */
2172                 ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
2173                 rtp->rtcp->us.sin_port = htons(ntohs(rtp->rtcp->us.sin_port) + 1);
2174
2175                 /* Try to actually bind to the IP address and port we are going to use for RTCP, if this fails we have to bail out */
2176                 if (bind(rtp->rtcp->s, (struct sockaddr*)&rtp->rtcp->us, sizeof(rtp->rtcp->us))) {
2177                         ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
2178                         close(rtp->rtcp->s);
2179                         ast_free(rtp->rtcp);
2180                         rtp->rtcp = NULL;
2181                         return;
2182                 }
2183
2184                 ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
2185                 rtp->rtcp->schedid = -1;
2186
2187                 return;
2188         }
2189
2190         return;
2191 }
2192
2193 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
2194 {
2195         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2196
2197         return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
2198 }
2199
2200 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2201 {
2202         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2203
2204         if (rtp->rtcp) {
2205                 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
2206                 memcpy(&rtp->rtcp->them, sin, sizeof(rtp->rtcp->them));
2207                 rtp->rtcp->them.sin_port = htons(ntohs(sin->sin_port) + 1);
2208         }
2209
2210         rtp->rxseqno = 0;
2211
2212         if (strictrtp) {
2213                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2214         }
2215
2216         return;
2217 }
2218
2219 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2220 {
2221         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2222
2223         /* No need to futz with rtp->rtcp here because ast_rtcp_read is already able to adjust if receiving
2224          * RTCP from an "unexpected" source
2225          */
2226         rtp->alt_rtp_address = *sin;
2227
2228         return;
2229 }
2230
2231 /*! \brief Write t140 redundacy frame
2232  * \param data primary data to be buffered
2233  */
2234 static int red_write(const void *data)
2235 {
2236         struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
2237         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2238
2239         ast_rtp_write(instance, &rtp->red->t140);
2240
2241         return 1;
2242 }
2243
2244 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
2245 {
2246         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2247         int x;
2248
2249         if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
2250                 return -1;
2251         }
2252
2253         rtp->red->t140.frametype = AST_FRAME_TEXT;
2254         rtp->red->t140.subclass.codec = AST_FORMAT_T140RED;
2255         rtp->red->t140.data.ptr = &rtp->red->buf_data;
2256
2257         rtp->red->t140.ts = 0;
2258         rtp->red->t140red = rtp->red->t140;
2259         rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
2260         rtp->red->t140red.datalen = 0;
2261         rtp->red->ti = buffer_time;
2262         rtp->red->num_gen = generations;
2263         rtp->red->hdrlen = generations * 4 + 1;
2264         rtp->red->prev_ts = 0;
2265
2266         for (x = 0; x < generations; x++) {
2267                 rtp->red->pt[x] = payloads[x];
2268                 rtp->red->pt[x] |= 1 << 7; /* mark redundant generations pt */
2269                 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
2270         }
2271         rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x]; /* primary pt */
2272         rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
2273
2274         rtp->red->t140.datalen = 0;
2275
2276         return 0;
2277 }
2278
2279 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
2280 {
2281         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2282
2283         if (frame->datalen > -1) {
2284                 struct rtp_red *red = rtp->red;
2285                 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
2286                 red->t140.datalen += frame->datalen;
2287                 red->t140.ts = frame->ts;
2288         }
2289
2290         return 0;
2291 }
2292
2293 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
2294 {
2295         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
2296
2297         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2298
2299         return 0;
2300 }
2301
2302 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
2303 {
2304         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2305
2306         if (!rtp->rtcp) {
2307                 return -1;
2308         }
2309
2310         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
2311         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
2312
2313         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
2314         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->rxploss, rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2315         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
2316         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
2317         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lost);
2318         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_stdevrxploss, rtp->rtcp->reported_stdev_lost);
2319         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_maxrxploss, rtp->rtcp->maxrxlost);
2320         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_minrxploss, rtp->rtcp->minrxlost);
2321         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_normdevrxploss, rtp->rtcp->normdev_rxlost);
2322         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_stdevrxploss, rtp->rtcp->stdev_rxlost);
2323         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_LOSS);
2324
2325         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->txjitter, rtp->rxjitter);
2326         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->rxjitter, rtp->rtcp->reported_jitter / (unsigned int) 65536.0);
2327         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_maxjitter, rtp->rtcp->reported_maxjitter);
2328         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_minjitter, rtp->rtcp->reported_minjitter);
2329         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_normdevjitter, rtp->rtcp->reported_normdev_jitter);
2330         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_stdevjitter, rtp->rtcp->reported_stdev_jitter);
2331         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_maxjitter, rtp->rtcp->maxrxjitter);
2332         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_minjitter, rtp->rtcp->minrxjitter);
2333         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_normdevjitter, rtp->rtcp->normdev_rxjitter);
2334         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_stdevjitter, rtp->rtcp->stdev_rxjitter);
2335         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_JITTER);
2336
2337         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->rtt, rtp->rtcp->rtt);
2338         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MAX_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->maxrtt, rtp->rtcp->maxrtt);
2339         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MIN_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->minrtt, rtp->rtcp->minrtt);
2340         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_NORMDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->normdevrtt, rtp->rtcp->normdevrtt);
2341         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_STDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->stdevrtt, rtp->rtcp->stdevrtt);
2342         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_RTT);
2343
2344         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_SSRC, -1, stats->local_ssrc, rtp->ssrc);
2345         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_SSRC, -1, stats->remote_ssrc, rtp->themssrc);
2346
2347         return 0;
2348 }
2349
2350 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
2351 {
2352         /* If both sides are not using the same method of DTMF transmission
2353          * (ie: one is RFC2833, other is INFO... then we can not do direct media.
2354          * --------------------------------------------------
2355          * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
2356          * |-----------|------------|-----------------------|
2357          * | Inband    | False      | True                  |
2358          * | RFC2833   | True       | True                  |
2359          * | SIP INFO  | False      | False                 |
2360          * --------------------------------------------------
2361          */
2362         return (((ast_rtp_instance_get_prop(instance0, AST_RTP_PROPERTY_DTMF) != ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_DTMF)) ||
2363                  (!chan0->tech->send_digit_begin != !chan1->tech->send_digit_begin)) ? 0 : 1);
2364 }
2365
2366 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username)
2367 {
2368         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2369
2370         ast_stun_request(rtp->s, suggestion, username, NULL);
2371 }
2372
2373 static void ast_rtp_stop(struct ast_rtp_instance *instance)
2374 {
2375         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2376         struct sockaddr_in sin = { 0, };
2377
2378         if (rtp->rtcp) {
2379                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2380         }
2381         if (rtp->red) {
2382                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2383                 free(rtp->red);
2384                 rtp->red = NULL;
2385         }
2386
2387         ast_rtp_instance_set_remote_address(instance, &sin);
2388         if (rtp->rtcp) {
2389                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2390                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2391         }
2392
2393         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2394 }
2395
2396 static char *rtp_do_debug_ip(struct ast_cli_args *a)
2397 {
2398         struct hostent *hp;
2399         struct ast_hostent ahp;
2400         int port = 0;
2401         char *p, *arg = ast_strdupa(a->argv[4]);
2402
2403         p = strstr(arg, ":");
2404         if (p) {
2405                 *p = '\0';
2406                 p++;
2407                 port = atoi(p);
2408         }
2409         hp = ast_gethostbyname(arg, &ahp);
2410         if (hp == NULL) {
2411                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2412                 return CLI_FAILURE;
2413         }
2414         rtpdebugaddr.sin_family = AF_INET;
2415         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2416         rtpdebugaddr.sin_port = htons(port);
2417         if (port == 0)
2418                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
2419         else
2420                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
2421         rtpdebug = 1;
2422         return CLI_SUCCESS;
2423 }
2424
2425 static char *rtcp_do_debug_ip(struct ast_cli_args *a)
2426 {
2427         struct hostent *hp;
2428         struct ast_hostent ahp;
2429         int port = 0;
2430         char *p, *arg = ast_strdupa(a->argv[3]);
2431
2432         p = strstr(arg, ":");
2433         if (p) {
2434                 *p = '\0';
2435                 p++;
2436                 port = atoi(p);
2437         }
2438         hp = ast_gethostbyname(arg, &ahp);
2439         if (hp == NULL) {
2440                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2441                 return CLI_FAILURE;
2442         }
2443         rtcpdebugaddr.sin_family = AF_INET;
2444         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
2445         rtcpdebugaddr.sin_port = htons(port);
2446         if (port == 0)
2447                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
2448         else
2449                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
2450         rtcpdebug = 1;
2451         return CLI_SUCCESS;
2452 }
2453
2454 static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2455 {
2456         switch (cmd) {
2457         case CLI_INIT:
2458                 e->command = "rtp set debug {on|off|ip}";
2459                 e->usage =
2460                         "Usage: rtp set debug {on|off|ip host[:port]}\n"
2461                         "       Enable/Disable dumping of all RTP packets. If 'ip' is\n"
2462                         "       specified, limit the dumped packets to those to and from\n"
2463                         "       the specified 'host' with optional port.\n";
2464                 return NULL;
2465         case CLI_GENERATE:
2466                 return NULL;
2467         }
2468
2469         if (a->argc == e->args) { /* set on or off */
2470                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2471                         rtpdebug = 1;
2472                         memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
2473                         ast_cli(a->fd, "RTP Debugging Enabled\n");
2474                         return CLI_SUCCESS;
2475                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2476                         rtpdebug = 0;
2477                         ast_cli(a->fd, "RTP Debugging Disabled\n");
2478                         return CLI_SUCCESS;
2479                 }
2480         } else if (a->argc == e->args +1) { /* ip */
2481                 return rtp_do_debug_ip(a);
2482         }
2483
2484         return CLI_SHOWUSAGE;   /* default, failure */
2485 }
2486
2487 static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2488 {
2489         switch (cmd) {
2490         case CLI_INIT:
2491                 e->command = "rtcp set debug {on|off|ip}";
2492                 e->usage =
2493                         "Usage: rtcp set debug {on|off|ip host[:port]}\n"
2494                         "       Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
2495                         "       specified, limit the dumped packets to those to and from\n"
2496                         "       the specified 'host' with optional port.\n";
2497                 return NULL;
2498         case CLI_GENERATE:
2499                 return NULL;
2500         }
2501
2502         if (a->argc == e->args) { /* set on or off */
2503                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2504                         rtcpdebug = 1;
2505                         memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
2506                         ast_cli(a->fd, "RTCP Debugging Enabled\n");
2507                         return CLI_SUCCESS;
2508                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2509                         rtcpdebug = 0;
2510                         ast_cli(a->fd, "RTCP Debugging Disabled\n");
2511                         return CLI_SUCCESS;
2512                 }
2513         } else if (a->argc == e->args +1) { /* ip */
2514                 return rtcp_do_debug_ip(a);
2515         }
2516
2517         return CLI_SHOWUSAGE;   /* default, failure */
2518 }
2519
2520 static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2521 {
2522         switch (cmd) {
2523         case CLI_INIT:
2524                 e->command = "rtcp set stats {on|off}";
2525                 e->usage =
2526                         "Usage: rtcp set stats {on|off}\n"
2527                         "       Enable/Disable dumping of RTCP stats.\n";
2528                 return NULL;
2529         case CLI_GENERATE:
2530                 return NULL;
2531         }
2532
2533         if (a->argc != e->args)
2534                 return CLI_SHOWUSAGE;
2535
2536         if (!strncasecmp(a->argv[e->args-1], "on", 2))
2537                 rtcpstats = 1;
2538         else if (!strncasecmp(a->argv[e->args-1], "off", 3))
2539                 rtcpstats = 0;
2540         else
2541                 return CLI_SHOWUSAGE;
2542
2543         ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
2544         return CLI_SUCCESS;
2545 }
2546
2547 static struct ast_cli_entry cli_rtp[] = {
2548         AST_CLI_DEFINE(handle_cli_rtp_set_debug,  "Enable/Disable RTP debugging"),
2549         AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
2550         AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
2551 };
2552
2553 static int rtp_reload(int reload)
2554 {
2555         struct ast_config *cfg;
2556         const char *s;
2557         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
2558
2559         cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
2560         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
2561                 return 0;
2562         }
2563
2564         rtpstart = DEFAULT_RTP_START;
2565         rtpend = DEFAULT_RTP_END;
2566         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2567         strictrtp = STRICT_RTP_OPEN;
2568         if (cfg) {
2569                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2570                         rtpstart = atoi(s);
2571                         if (rtpstart < MINIMUM_RTP_PORT)
2572                                 rtpstart = MINIMUM_RTP_PORT;
2573                         if (rtpstart > MAXIMUM_RTP_PORT)
2574                                 rtpstart = MAXIMUM_RTP_PORT;
2575                 }
2576                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2577                         rtpend = atoi(s);
2578                         if (rtpend < MINIMUM_RTP_PORT)
2579                                 rtpend = MINIMUM_RTP_PORT;
2580                         if (rtpend > MAXIMUM_RTP_PORT)
2581                                 rtpend = MAXIMUM_RTP_PORT;
2582                 }
2583                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
2584                         rtcpinterval = atoi(s);
2585                         if (rtcpinterval == 0)
2586                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
2587                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
2588                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
2589                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
2590                                 rtcpinterval = RTCP_MAX_INTERVALMS;
2591                 }
2592                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2593 #ifdef SO_NO_CHECK
2594                         nochecksums = ast_false(s) ? 1 : 0;
2595 #else
2596                         if (ast_false(s))
2597                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2598 #endif
2599                 }
2600                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2601                         dtmftimeout = atoi(s);
2602                         if ((dtmftimeout < 0) || (dtmftimeout > 64000)) {
2603                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2604                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2605                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2606                         };
2607                 }
2608                 if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
2609                         strictrtp = ast_true(s);
2610                 }
2611                 ast_config_destroy(cfg);
2612         }
2613         if (rtpstart >= rtpend) {
2614                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2615                 rtpstart = DEFAULT_RTP_START;
2616                 rtpend = DEFAULT_RTP_END;
2617         }
2618         ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2619         return 0;
2620 }
2621
2622 static int reload_module(void)
2623 {
2624         rtp_reload(1);
2625         return 0;
2626 }
2627
2628 static int load_module(void)
2629 {
2630         if (ast_rtp_engine_register(&asterisk_rtp_engine)) {
2631                 return AST_MODULE_LOAD_DECLINE;
2632         }
2633
2634         if (ast_cli_register_multiple(cli_rtp, ARRAY_LEN(cli_rtp))) {
2635                 ast_rtp_engine_unregister(&asterisk_rtp_engine);
2636                 return AST_MODULE_LOAD_DECLINE;
2637         }
2638
2639         rtp_reload(0);
2640
2641         return AST_MODULE_LOAD_SUCCESS;
2642 }
2643
2644 static int unload_module(void)
2645 {
2646         ast_rtp_engine_unregister(&asterisk_rtp_engine);
2647         ast_cli_unregister_multiple(cli_rtp, ARRAY_LEN(cli_rtp));
2648
2649         return 0;
2650 }
2651
2652 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk RTP Stack",
2653                 .load = load_module,
2654                 .unload = unload_module,
2655                 .reload = reload_module,
2656                 );