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