Remove spurious debug
[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 calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1216 {
1217         struct timeval now;
1218         double transit;
1219         double current_time;
1220         double d;
1221         double dtv;
1222         double prog;
1223         int rate = rtp_get_rate(rtp->f.subclass);
1224
1225         double normdev_rxjitter_current;
1226         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1227                 gettimeofday(&rtp->rxcore, NULL);
1228                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1229                 /* map timestamp to a real time */
1230                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1231                 rtp->rxcore.tv_sec -= timestamp / rate;
1232                 rtp->rxcore.tv_usec -= (timestamp % rate) * 125;
1233                 /* Round to 0.1ms for nice, pretty timestamps */
1234                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1235                 if (rtp->rxcore.tv_usec < 0) {
1236                         /* Adjust appropriately if necessary */
1237                         rtp->rxcore.tv_usec += 1000000;
1238                         rtp->rxcore.tv_sec -= 1;
1239                 }
1240         }
1241
1242         gettimeofday(&now,NULL);
1243         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1244         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / rate;
1245         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % rate) * 125;
1246         if (tv->tv_usec >= 1000000) {
1247                 tv->tv_usec -= 1000000;
1248                 tv->tv_sec += 1;
1249         }
1250         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
1251         dtv = (double)rtp->drxcore + (double)(prog);
1252         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1253         transit = current_time - dtv;
1254         d = transit - rtp->rxtransit;
1255         rtp->rxtransit = transit;
1256         if (d<0)
1257                 d=-d;
1258         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1259
1260         if (rtp->rtcp) {
1261                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
1262                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
1263                 if (rtp->rtcp->rxjitter_count == 1)
1264                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1265                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1266                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1267
1268                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
1269                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
1270
1271                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
1272                 rtp->rtcp->rxjitter_count++;
1273         }
1274 }
1275
1276 static struct ast_frame *send_dtmf(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
1277 {
1278         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1279         struct sockaddr_in remote_address = { 0, };
1280
1281         ast_rtp_instance_get_remote_address(instance, &remote_address);
1282
1283         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
1284                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(remote_address.sin_addr));
1285                 rtp->resp = 0;
1286                 rtp->dtmfsamples = 0;
1287                 return &ast_null_frame;
1288         }
1289         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(remote_address.sin_addr));
1290         if (rtp->resp == 'X') {
1291                 rtp->f.frametype = AST_FRAME_CONTROL;
1292                 rtp->f.subclass = AST_CONTROL_FLASH;
1293         } else {
1294                 rtp->f.frametype = type;
1295                 rtp->f.subclass = rtp->resp;
1296         }
1297         rtp->f.datalen = 0;
1298         rtp->f.samples = 0;
1299         rtp->f.mallocd = 0;
1300         rtp->f.src = "RTP";
1301
1302         return &rtp->f;
1303 }
1304
1305 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)
1306 {
1307         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1308         struct sockaddr_in remote_address = { 0, };
1309         unsigned int event, event_end, samples;
1310         char resp = 0;
1311         struct ast_frame *f = NULL;
1312
1313         ast_rtp_instance_get_remote_address(instance, &remote_address);
1314
1315         /* Figure out event, event end, and samples */
1316         event = ntohl(*((unsigned int *)(data)));
1317         event >>= 24;
1318         event_end = ntohl(*((unsigned int *)(data)));
1319         event_end <<= 8;
1320         event_end >>= 24;
1321         samples = ntohl(*((unsigned int *)(data)));
1322         samples &= 0xFFFF;
1323
1324         if (rtp_debug_test_addr(&remote_address)) {
1325                 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),
1326                             ntohs(remote_address.sin_port), payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
1327         }
1328
1329         /* Print out debug if turned on */
1330         if (rtpdebug || option_debug > 2)
1331                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
1332
1333         /* Figure out what digit was pressed */
1334         if (event < 10) {
1335                 resp = '0' + event;
1336         } else if (event < 11) {
1337                 resp = '*';
1338         } else if (event < 12) {
1339                 resp = '#';
1340         } else if (event < 16) {
1341                 resp = 'A' + (event - 12);
1342         } else if (event < 17) {        /* Event 16: Hook flash */
1343                 resp = 'X';
1344         } else {
1345                 /* Not a supported event */
1346                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
1347                 return &ast_null_frame;
1348         }
1349
1350         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1351                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
1352                         rtp->resp = resp;
1353                         rtp->dtmf_timeout = 0;
1354                         f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1355                         f->len = 0;
1356                         rtp->lastevent = timestamp;
1357                 }
1358         } else {
1359                 /*  The duration parameter measures the complete
1360                     duration of the event (from the beginning) - RFC2833.
1361                     Account for the fact that duration is only 16 bits long
1362                     (about 8 seconds at 8000 Hz) and can wrap is digit
1363                     is hold for too long. */
1364                 unsigned int new_duration = rtp->dtmf_duration;
1365                 unsigned int last_duration = new_duration & 0xFFFF;
1366
1367                 if (last_duration > 64000 && samples < last_duration) {
1368                         new_duration += 0xFFFF + 1;
1369                 }
1370                 new_duration = (new_duration & ~0xFFFF) | samples;
1371
1372                 if (event_end & 0x80) {
1373                         /* End event */
1374                         if ((rtp->lastevent != seqno) && rtp->resp) {
1375                                 rtp->dtmf_duration = new_duration;
1376                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1377                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
1378                                 rtp->resp = 0;
1379                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1380                         }
1381                 } else {
1382                         /* Begin/continuation */
1383
1384                         if (rtp->resp && rtp->resp != resp) {
1385                                 /* Another digit already began. End it */
1386                                 f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
1387                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
1388                                 rtp->resp = 0;
1389                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1390                         }
1391
1392                         if (rtp->resp) {
1393                                 /* Digit continues */
1394                                 rtp->dtmf_duration = new_duration;
1395                         } else {
1396                                 /* New digit began */
1397                                 rtp->resp = resp;
1398                                 f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1399                                 rtp->dtmf_duration = samples;
1400                         }
1401
1402                         rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
1403                 }
1404
1405                 rtp->lastevent = seqno;
1406         }
1407
1408         rtp->dtmfsamples = samples;
1409
1410         return f;
1411 }
1412
1413 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)
1414 {
1415         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1416         unsigned int event, flags, power;
1417         char resp = 0;
1418         unsigned char seq;
1419         struct ast_frame *f = NULL;
1420
1421         if (len < 4) {
1422                 return NULL;
1423         }
1424
1425         /*      The format of Cisco RTP DTMF packet looks like next:
1426                 +0                              - sequence number of DTMF RTP packet (begins from 1,
1427                                                   wrapped to 0)
1428                 +1                              - set of flags
1429                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
1430                                                   or repeated digit without audio???
1431                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
1432                                                   then falls to 0 at its end)
1433                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
1434                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
1435                 by each new packet and thus provides some redudancy.
1436
1437                 Sample of Cisco RTP DTMF packet is (all data in hex):
1438                         19 07 00 02 12 02 20 02
1439                 showing end of DTMF digit '2'.
1440
1441                 The packets
1442                         27 07 00 02 0A 02 20 02
1443                         28 06 20 02 00 02 0A 02
1444                 shows begin of new digit '2' with very short pause (20 ms) after
1445                 previous digit '2'. Bit +1.0 flips at begin of new digit.
1446
1447                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
1448                 so its uses the same sequencing and timestamping rules as replaced
1449                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
1450                 on audio framing parameters. Marker bit isn't used within stream of
1451                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
1452                 are not sequential at borders between DTMF and audio streams,
1453         */
1454
1455         seq = data[0];
1456         flags = data[1];
1457         power = data[2];
1458         event = data[3] & 0x1f;
1459
1460         if (option_debug > 2 || rtpdebug)
1461                 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);
1462         if (event < 10) {
1463                 resp = '0' + event;
1464         } else if (event < 11) {
1465                 resp = '*';
1466         } else if (event < 12) {
1467                 resp = '#';
1468         } else if (event < 16) {
1469                 resp = 'A' + (event - 12);
1470         } else if (event < 17) {
1471                 resp = 'X';
1472         }
1473         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
1474                 rtp->resp = resp;
1475                 /* Why we should care on DTMF compensation at reception? */
1476                 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1477                         f = send_dtmf(instance, AST_FRAME_DTMF_BEGIN, 0);
1478                         rtp->dtmfsamples = 0;
1479                 }
1480         } else if ((rtp->resp == resp) && !power) {
1481                 f = send_dtmf(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1482                 f->samples = rtp->dtmfsamples * (rtp_get_rate(f->subclass) / 1000);
1483                 rtp->resp = 0;
1484         } else if (rtp->resp == resp)
1485                 rtp->dtmfsamples += 20 * (rtp_get_rate(f->subclass) / 1000);
1486         rtp->dtmf_timeout = 0;
1487
1488         return f;
1489 }
1490
1491 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)
1492 {
1493         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1494
1495         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1496            totally help us out becuase we don't have an engine to keep it going and we are not
1497            guaranteed to have it every 20ms or anything */
1498         if (rtpdebug)
1499                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
1500
1501         if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
1502                 struct sockaddr_in remote_address = { 0, };
1503
1504                 ast_rtp_instance_get_remote_address(instance, &remote_address);
1505
1506                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
1507                         ast_inet_ntoa(remote_address.sin_addr));
1508                 ast_set_flag(rtp, FLAG_3389_WARNING);
1509         }
1510
1511         /* Must have at least one byte */
1512         if (!len)
1513                 return NULL;
1514         if (len < 24) {
1515                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
1516                 rtp->f.datalen = len - 1;
1517                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1518                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
1519         } else {
1520                 rtp->f.data.ptr = NULL;
1521                 rtp->f.offset = 0;
1522                 rtp->f.datalen = 0;
1523         }
1524         rtp->f.frametype = AST_FRAME_CNG;
1525         rtp->f.subclass = data[0] & 0x7f;
1526         rtp->f.datalen = len - 1;
1527         rtp->f.samples = 0;
1528         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1529
1530         return &rtp->f;
1531 }
1532
1533 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
1534 {
1535         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1536         struct sockaddr_in sin;
1537         socklen_t len = sizeof(sin);
1538         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1539         unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1540         int res, packetwords, position = 0;
1541         struct ast_frame *f = &ast_null_frame;
1542
1543         /* Read in RTCP data from the socket */
1544         if ((res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0) {
1545                 ast_assert(errno != EBADF);
1546                 if (errno != EAGAIN) {
1547                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1548                         return NULL;
1549                 }
1550                 return &ast_null_frame;
1551         }
1552
1553         packetwords = res / 4;
1554
1555         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1556                 /* Send to whoever sent to us */
1557                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1558                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
1559                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1560                         if (option_debug || rtpdebug)
1561                                 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));
1562                 }
1563         }
1564
1565         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1566
1567         while (position < packetwords) {
1568                 int i, pt, rc;
1569                 unsigned int length, dlsr, lsr, msw, lsw, comp;
1570                 struct timeval now;
1571                 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
1572                 uint64_t rtt = 0;
1573
1574                 i = position;
1575                 length = ntohl(rtcpheader[i]);
1576                 pt = (length & 0xff0000) >> 16;
1577                 rc = (length & 0x1f000000) >> 24;
1578                 length &= 0xffff;
1579
1580                 if ((i + length) > packetwords) {
1581                         if (option_debug || rtpdebug)
1582                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1583                         return &ast_null_frame;
1584                 }
1585
1586                 if (rtcp_debug_test_addr(&sin)) {
1587                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
1588                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1589                         ast_verbose("Reception reports: %d\n", rc);
1590                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1591                 }
1592
1593                 i += 2; /* Advance past header and ssrc */
1594
1595                 switch (pt) {
1596                 case RTCP_PT_SR:
1597                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1598                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1599                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1600                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1601
1602                         if (rtcp_debug_test_addr(&sin)) {
1603                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1604                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1605                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1606                         }
1607                         i += 5;
1608                         if (rc < 1)
1609                                 break;
1610                         /* Intentional fall through */
1611                 case RTCP_PT_RR:
1612                         /* Don't handle multiple reception reports (rc > 1) yet */
1613                         /* Calculate RTT per RFC */
1614                         gettimeofday(&now, NULL);
1615                         timeval2ntp(now, &msw, &lsw);
1616                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1617                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1618                                 lsr = ntohl(rtcpheader[i + 4]);
1619                                 dlsr = ntohl(rtcpheader[i + 5]);
1620                                 rtt = comp - lsr - dlsr;
1621
1622                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1623                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1624                                 if (rtt < 4294) {
1625                                         rtt = (rtt * 1000000) >> 16;
1626                                 } else {
1627                                         rtt = (rtt * 1000) >> 16;
1628                                         rtt *= 1000;
1629                                 }
1630                                 rtt = rtt / 1000.;
1631                                 rttsec = rtt / 1000.;
1632                                 rtp->rtcp->rtt = rttsec;
1633
1634                                 if (comp - dlsr >= lsr) {
1635                                         rtp->rtcp->accumulated_transit += rttsec;
1636
1637                                         if (rtp->rtcp->rtt_count == 0)
1638                                                 rtp->rtcp->minrtt = rttsec;
1639
1640                                         if (rtp->rtcp->maxrtt<rttsec)
1641                                                 rtp->rtcp->maxrtt = rttsec;
1642                                         if (rtp->rtcp->minrtt>rttsec)
1643                                                 rtp->rtcp->minrtt = rttsec;
1644
1645                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
1646
1647                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
1648
1649                                         rtp->rtcp->normdevrtt = normdevrtt_current;
1650
1651                                         rtp->rtcp->rtt_count++;
1652                                 } else if (rtcp_debug_test_addr(&sin)) {
1653                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1654                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1655                                                     "diff=%d\n",
1656                                                     lsr, comp, dlsr, dlsr / 65536,
1657                                                     (dlsr % 65536) * 1000 / 65536,
1658                                                     dlsr - (comp - lsr));
1659                                 }
1660                         }
1661
1662                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1663                         reported_jitter = (double) rtp->rtcp->reported_jitter;
1664
1665                         if (rtp->rtcp->reported_jitter_count == 0)
1666                                 rtp->rtcp->reported_minjitter = reported_jitter;
1667
1668                         if (reported_jitter < rtp->rtcp->reported_minjitter)
1669                                 rtp->rtcp->reported_minjitter = reported_jitter;
1670
1671                         if (reported_jitter > rtp->rtcp->reported_maxjitter)
1672                                 rtp->rtcp->reported_maxjitter = reported_jitter;
1673
1674                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
1675
1676                         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);
1677
1678                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
1679
1680                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1681
1682                         reported_lost = (double) rtp->rtcp->reported_lost;
1683
1684                         /* using same counter as for jitter */
1685                         if (rtp->rtcp->reported_jitter_count == 0)
1686                                 rtp->rtcp->reported_minlost = reported_lost;
1687
1688                         if (reported_lost < rtp->rtcp->reported_minlost)
1689                                 rtp->rtcp->reported_minlost = reported_lost;
1690
1691                         if (reported_lost > rtp->rtcp->reported_maxlost)
1692                                 rtp->rtcp->reported_maxlost = reported_lost;
1693                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
1694
1695                         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);
1696
1697                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
1698
1699                         rtp->rtcp->reported_jitter_count++;
1700
1701                         if (rtcp_debug_test_addr(&sin)) {
1702                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1703                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1704                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1705                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1706                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1707                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1708                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1709                                 if (rtt)
1710                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1711                         }
1712                         if (rtt) {
1713                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1714                                                                     "PT: %d(%s)\r\n"
1715                                                                     "ReceptionReports: %d\r\n"
1716                                                                     "SenderSSRC: %u\r\n"
1717                                                                     "FractionLost: %ld\r\n"
1718                                                                     "PacketsLost: %d\r\n"
1719                                                                     "HighestSequence: %ld\r\n"
1720                                                                     "SequenceNumberCycles: %ld\r\n"
1721                                                                     "IAJitter: %u\r\n"
1722                                                                     "LastSR: %lu.%010lu\r\n"
1723                                                                     "DLSR: %4.4f(sec)\r\n"
1724                                               "RTT: %llu(sec)\r\n",
1725                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1726                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1727                                               rc,
1728                                               rtcpheader[i + 1],
1729                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1730                                               rtp->rtcp->reported_lost,
1731                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1732                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1733                                               rtp->rtcp->reported_jitter,
1734                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1735                                               ntohl(rtcpheader[i + 5])/65536.0,
1736                                               (unsigned long long)rtt);
1737                         } else {
1738                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1739                                                                     "PT: %d(%s)\r\n"
1740                                                                     "ReceptionReports: %d\r\n"
1741                                                                     "SenderSSRC: %u\r\n"
1742                                                                     "FractionLost: %ld\r\n"
1743                                                                     "PacketsLost: %d\r\n"
1744                                                                     "HighestSequence: %ld\r\n"
1745                                                                     "SequenceNumberCycles: %ld\r\n"
1746                                                                     "IAJitter: %u\r\n"
1747                                                                     "LastSR: %lu.%010lu\r\n"
1748                                               "DLSR: %4.4f(sec)\r\n",
1749                                               ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1750                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1751                                               rc,
1752                                               rtcpheader[i + 1],
1753                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1754                                               rtp->rtcp->reported_lost,
1755                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1756                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1757                                               rtp->rtcp->reported_jitter,
1758                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1759                                               ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1760                                               ntohl(rtcpheader[i + 5])/65536.0);
1761                         }
1762                         break;
1763                 case RTCP_PT_FUR:
1764                         if (rtcp_debug_test_addr(&sin))
1765                                 ast_verbose("Received an RTCP Fast Update Request\n");
1766                         rtp->f.frametype = AST_FRAME_CONTROL;
1767                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1768                         rtp->f.datalen = 0;
1769                         rtp->f.samples = 0;
1770                         rtp->f.mallocd = 0;
1771                         rtp->f.src = "RTP";
1772                         f = &rtp->f;
1773                         break;
1774                 case RTCP_PT_SDES:
1775                         if (rtcp_debug_test_addr(&sin))
1776                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1777                         break;
1778                 case RTCP_PT_BYE:
1779                         if (rtcp_debug_test_addr(&sin))
1780                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1781                         break;
1782                 default:
1783                         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));
1784                         break;
1785                 }
1786                 position += (length + 1);
1787         }
1788
1789         rtp->rtcp->rtcp_info = 1;
1790
1791         return f;
1792 }
1793
1794 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
1795 {
1796         struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
1797         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
1798         int res = 0, payload = 0, bridged_payload = 0, mark;
1799         struct ast_rtp_payload_type payload_type;
1800         int reconstruct = ntohl(rtpheader[0]);
1801         struct sockaddr_in remote_address = { 0, };
1802
1803         /* Get fields from packet */
1804         payload = (reconstruct & 0x7f0000) >> 16;
1805         mark = (((reconstruct & 0x800000) >> 23) != 0);
1806
1807         /* Check what the payload value should be */
1808         payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
1809
1810         /* Otherwise adjust bridged payload to match */
1811         bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, payload_type.code);
1812
1813         /* 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 */
1814         if (!(ast_rtp_instance_get_codecs(instance1)->payloads[bridged_payload].code)) {
1815                 return -1;
1816         }
1817
1818         /* If the marker bit has been explicitly set turn it on */
1819         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1820                 mark = 1;
1821                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1822         }
1823
1824         /* Reconstruct part of the packet */
1825         reconstruct &= 0xFF80FFFF;
1826         reconstruct |= (bridged_payload << 16);
1827         reconstruct |= (mark << 23);
1828         rtpheader[0] = htonl(reconstruct);
1829
1830         ast_rtp_instance_get_remote_address(instance1, &remote_address);
1831
1832         /* Send the packet back out */
1833         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&remote_address, sizeof(remote_address));
1834         if (res < 0) {
1835                 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))) {
1836                         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));
1837                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1838                         if (option_debug || rtpdebug)
1839                                 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));
1840                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1841                 }
1842                 return 0;
1843         } else if (rtp_debug_test_addr(&remote_address)) {
1844                 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);
1845         }
1846
1847         return 0;
1848 }
1849
1850 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
1851 {
1852         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1853         struct sockaddr_in sin;
1854         socklen_t len = sizeof(sin);
1855         int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
1856         unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
1857         struct ast_rtp_payload_type payload;
1858         struct sockaddr_in remote_address = { 0, };
1859
1860         /* If this is actually RTCP let's hop on over and handle it */
1861         if (rtcp) {
1862                 if (rtp->rtcp) {
1863                         return ast_rtcp_read(instance);
1864                 }
1865                 return &ast_null_frame;
1866         }
1867
1868         /* If we are currently sending DTMF to the remote party send a continuation packet */
1869         if (rtp->sending_digit) {
1870                 ast_rtp_dtmf_continuation(instance);
1871         }
1872
1873         /* Actually read in the data from the socket */
1874         if ((res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr*)&sin, &len)) < 0) {
1875                 ast_assert(errno != EBADF);
1876                 if (errno != EAGAIN) {
1877                         ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
1878                         return NULL;
1879                 }
1880                 return &ast_null_frame;
1881         }
1882
1883         /* Make sure the data that was read in is actually enough to make up an RTP packet */
1884         if (res < hdrlen) {
1885                 ast_log(LOG_WARNING, "RTP Read too short\n");
1886                 return &ast_null_frame;
1887         }
1888
1889         /* If strict RTP protection is enabled see if we need to learn the remote address or if we need to drop the packet */
1890         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
1891                 memcpy(&rtp->strict_rtp_address, &sin, sizeof(rtp->strict_rtp_address));
1892                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
1893         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
1894                 if ((rtp->strict_rtp_address.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->strict_rtp_address.sin_port != sin.sin_port)) {
1895                         /* Hmm, not the strict addres. Perhaps we're getting audio from the alternate? */
1896                         if ((rtp->alt_rtp_address.sin_addr.s_addr == sin.sin_addr.s_addr) && (rtp->alt_rtp_address.sin_port == sin.sin_port)) {
1897                                 /* ooh, we did! You're now the new expected address, son! */
1898                                 rtp->strict_rtp_address = sin;
1899                         } else  {
1900                                 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));
1901                                 return &ast_null_frame;
1902                         }
1903                 }
1904         }
1905
1906         /* Get fields and verify this is an RTP packet */
1907         seqno = ntohl(rtpheader[0]);
1908
1909         ast_rtp_instance_get_remote_address(instance, &remote_address);
1910
1911         if (!(version = (seqno & 0xC0000000) >> 30)) {
1912                 if ((ast_stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
1913                     (!remote_address.sin_port && !remote_address.sin_addr.s_addr)) {
1914                         ast_rtp_instance_set_remote_address(instance, &sin);
1915                 }
1916                 return &ast_null_frame;
1917         }
1918
1919         /* If symmetric RTP is enabled see if the remote side is not what we expected and change where we are sending audio */
1920         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1921                 if ((remote_address.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1922                     (remote_address.sin_port != sin.sin_port)) {
1923                         ast_rtp_instance_set_remote_address(instance, &sin);
1924                         memcpy(&remote_address, &sin, sizeof(remote_address));
1925                         if (rtp->rtcp) {
1926                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1927                                 rtp->rtcp->them.sin_port = htons(ntohs(sin.sin_port)+1);
1928                         }
1929                         rtp->rxseqno = 0;
1930                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1931                         if (option_debug || rtpdebug)
1932                                 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));
1933                 }
1934         }
1935
1936         /* If we are directly bridged to another instance send the audio directly out */
1937         if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
1938                 return &ast_null_frame;
1939         }
1940
1941         /* If the version is not what we expected by this point then just drop the packet */
1942         if (version != 2) {
1943                 return &ast_null_frame;
1944         }
1945
1946         /* Pull out the various other fields we will need */
1947         payloadtype = (seqno & 0x7f0000) >> 16;
1948         padding = seqno & (1 << 29);
1949         mark = seqno & (1 << 23);
1950         ext = seqno & (1 << 28);
1951         cc = (seqno & 0xF000000) >> 24;
1952         seqno &= 0xffff;
1953         timestamp = ntohl(rtpheader[1]);
1954         ssrc = ntohl(rtpheader[2]);
1955
1956         /* Force a marker bit if the SSRC changes */
1957         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1958                 if (option_debug || rtpdebug) {
1959                         ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
1960                 }
1961                 mark = 1;
1962         }
1963
1964         /* Remove any padding bytes that may be present */
1965         if (padding) {
1966                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1967         }
1968
1969         /* Skip over any CSRC fields */
1970         if (cc) {
1971                 hdrlen += cc * 4;
1972         }
1973
1974         /* Look for any RTP extensions, currently we do not support any */
1975         if (ext) {
1976                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1977                 hdrlen += 4;
1978                 if (option_debug) {
1979                         int profile;
1980                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1981                         if (profile == 0x505a)
1982                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1983                         else
1984                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1985                 }
1986         }
1987
1988         /* Make sure after we potentially mucked with the header length that it is once again valid */
1989         if (res < hdrlen) {
1990                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
1991                 return &ast_null_frame;
1992         }
1993
1994         rtp->rxcount++;
1995         if (rtp->rxcount == 1) {
1996                 rtp->seedrxseqno = seqno;
1997         }
1998
1999         /* Do not schedule RR if RTCP isn't run */
2000         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
2001                 /* Schedule transmission of Receiver Report */
2002                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2003         }
2004         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
2005                 rtp->cycles += RTP_SEQ_MOD;
2006
2007         prev_seqno = rtp->lastrxseqno;
2008         rtp->lastrxseqno = seqno;
2009
2010         if (!rtp->themssrc) {
2011                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
2012         }
2013
2014         if (rtp_debug_test_addr(&sin)) {
2015                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2016                             ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
2017         }
2018
2019         payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
2020
2021         /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
2022         if (!payload.asterisk_format) {
2023                 struct ast_frame *f = NULL;
2024                 if (payload.code == AST_RTP_DTMF) {
2025                         f = process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2026                 } else if (payload.code == AST_RTP_CISCO_DTMF) {
2027                         f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2028                 } else if (payload.code == AST_RTP_CN) {
2029                         f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &sin, payloadtype, mark);
2030                 } else {
2031                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(remote_address.sin_addr));
2032                 }
2033
2034                 return f ? f : &ast_null_frame;
2035         }
2036
2037         rtp->lastrxformat = rtp->f.subclass = payload.code;
2038         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;
2039
2040         rtp->rxseqno = seqno;
2041
2042         if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
2043                 rtp->dtmf_timeout = 0;
2044
2045                 if (rtp->resp) {
2046                         struct ast_frame *f;
2047                         f = send_dtmf(instance, AST_FRAME_DTMF_END, 0);
2048                         f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass)), ast_tv(0, 0));
2049                         rtp->resp = 0;
2050                         rtp->dtmf_timeout = rtp->dtmf_duration = 0;
2051                         return f;
2052                 }
2053         }
2054
2055         rtp->lastrxts = timestamp;
2056
2057         rtp->f.src = "RTP";
2058         rtp->f.mallocd = 0;
2059         rtp->f.datalen = res - hdrlen;
2060         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
2061         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
2062         rtp->f.seqno = seqno;
2063
2064         if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
2065                 unsigned char *data = rtp->f.data.ptr;
2066
2067                 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
2068                 rtp->f.datalen +=3;
2069                 *data++ = 0xEF;
2070                 *data++ = 0xBF;
2071                 *data = 0xBD;
2072         }
2073
2074         if (rtp->f.subclass == AST_FORMAT_T140RED) {
2075                 unsigned char *data = rtp->f.data.ptr;
2076                 unsigned char *header_end;
2077                 int num_generations;
2078                 int header_length;
2079                 int len;
2080                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
2081                 int x;
2082
2083                 rtp->f.subclass = AST_FORMAT_T140;
2084                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
2085                 if (header_end == NULL) {
2086                         return &ast_null_frame;
2087                 }
2088                 header_end++;
2089
2090                 header_length = header_end - data;
2091                 num_generations = header_length / 4;
2092                 len = header_length;
2093
2094                 if (!diff) {
2095                         for (x = 0; x < num_generations; x++)
2096                                 len += data[x * 4 + 3];
2097
2098                         if (!(rtp->f.datalen - len))
2099                                 return &ast_null_frame;
2100
2101                         rtp->f.data.ptr += len;
2102                         rtp->f.datalen -= len;
2103                 } else if (diff > num_generations && diff < 10) {
2104                         len -= 3;
2105                         rtp->f.data.ptr += len;
2106                         rtp->f.datalen -= len;
2107
2108                         data = rtp->f.data.ptr;
2109                         *data++ = 0xEF;
2110                         *data++ = 0xBF;
2111                         *data = 0xBD;
2112                 } else {
2113                         for ( x = 0; x < num_generations - diff; x++)
2114                                 len += data[x * 4 + 3];
2115
2116                         rtp->f.data.ptr += len;
2117                         rtp->f.datalen -= len;
2118                 }
2119         }
2120
2121         if (rtp->f.subclass & AST_FORMAT_AUDIO_MASK) {
2122                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
2123                 if (rtp->f.subclass == AST_FORMAT_SLINEAR)
2124                         ast_frame_byteswap_be(&rtp->f);
2125                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
2126                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
2127                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
2128                 rtp->f.ts = timestamp / (rtp_get_rate(rtp->f.subclass) / 1000);
2129                 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass) / 1000));
2130         } else if (rtp->f.subclass & AST_FORMAT_VIDEO_MASK) {
2131                 /* Video -- samples is # of samples vs. 90000 */
2132                 if (!rtp->lastividtimestamp)
2133                         rtp->lastividtimestamp = timestamp;
2134                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
2135                 rtp->lastividtimestamp = timestamp;
2136                 rtp->f.delivery.tv_sec = 0;
2137                 rtp->f.delivery.tv_usec = 0;
2138                 /* Pass the RTP marker bit as bit 0 in the subclass field.
2139                  * This is ok because subclass is actually a bitmask, and
2140                  * the low bits represent audio formats, that are not
2141                  * involved here since we deal with video.
2142                  */
2143                 if (mark)
2144                         rtp->f.subclass |= 0x1;
2145         } else {
2146                 /* TEXT -- samples is # of samples vs. 1000 */
2147                 if (!rtp->lastitexttimestamp)
2148                         rtp->lastitexttimestamp = timestamp;
2149                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
2150                 rtp->lastitexttimestamp = timestamp;
2151                 rtp->f.delivery.tv_sec = 0;
2152                 rtp->f.delivery.tv_usec = 0;
2153         }
2154
2155         return &rtp->f;
2156 }
2157
2158 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
2159 {
2160         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2161
2162         if (property == AST_RTP_PROPERTY_RTCP) {
2163                 if (rtp->rtcp) {
2164                         ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
2165                         return;
2166                 }
2167                 if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
2168                         return;
2169                 }
2170                 if ((rtp->rtcp->s = create_new_socket("RTCP")) < 0) {
2171                         ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
2172                         ast_free(rtp->rtcp);
2173                         rtp->rtcp = NULL;
2174                         return;
2175                 }
2176
2177                 /* Grab the IP address and port we are going to use */
2178                 ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
2179                 rtp->rtcp->us.sin_port = htons(ntohs(rtp->rtcp->us.sin_port) + 1);
2180
2181                 /* 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 */
2182                 if (bind(rtp->rtcp->s, (struct sockaddr*)&rtp->rtcp->us, sizeof(rtp->rtcp->us))) {
2183                         ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
2184                         close(rtp->rtcp->s);
2185                         ast_free(rtp->rtcp);
2186                         rtp->rtcp = NULL;
2187                         return;
2188                 }
2189
2190                 ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
2191                 rtp->rtcp->schedid = -1;
2192
2193                 return;
2194         }
2195
2196         return;
2197 }
2198
2199 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
2200 {
2201         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2202
2203         return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
2204 }
2205
2206 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2207 {
2208         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2209
2210         if (rtp->rtcp) {
2211                 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
2212                 memcpy(&rtp->rtcp->them, sin, sizeof(rtp->rtcp->them));
2213                 rtp->rtcp->them.sin_port = htons(ntohs(sin->sin_port) + 1);
2214         }
2215
2216         rtp->rxseqno = 0;
2217
2218         if (strictrtp) {
2219                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2220         }
2221
2222         return;
2223 }
2224
2225 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct sockaddr_in *sin)
2226 {
2227         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2228
2229         /* No need to futz with rtp->rtcp here because ast_rtcp_read is already able to adjust if receiving
2230          * RTCP from an "unexpected" source
2231          */
2232         rtp->alt_rtp_address = *sin;
2233
2234         return;
2235 }
2236
2237 /*! \brief Write t140 redundacy frame
2238  * \param data primary data to be buffered
2239  */
2240 static int red_write(const void *data)
2241 {
2242         struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
2243         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2244
2245         ast_rtp_write(instance, &rtp->red->t140);
2246
2247         return 1;
2248 }
2249
2250 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
2251 {
2252         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2253         int x;
2254
2255         if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
2256                 return -1;
2257         }
2258
2259         rtp->red->t140.frametype = AST_FRAME_TEXT;
2260         rtp->red->t140.subclass = AST_FORMAT_T140RED;
2261         rtp->red->t140.data.ptr = &rtp->red->buf_data;
2262
2263         rtp->red->t140.ts = 0;
2264         rtp->red->t140red = rtp->red->t140;
2265         rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
2266         rtp->red->t140red.datalen = 0;
2267         rtp->red->ti = buffer_time;
2268         rtp->red->num_gen = generations;
2269         rtp->red->hdrlen = generations * 4 + 1;
2270         rtp->red->prev_ts = 0;
2271
2272         for (x = 0; x < generations; x++) {
2273                 rtp->red->pt[x] = payloads[x];
2274                 rtp->red->pt[x] |= 1 << 7; /* mark redundant generations pt */
2275                 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
2276         }
2277         rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x]; /* primary pt */
2278         rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
2279
2280         rtp->red->t140.datalen = 0;
2281
2282         return 0;
2283 }
2284
2285 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
2286 {
2287         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2288
2289         if (frame->datalen > -1) {
2290                 struct rtp_red *red = rtp->red;
2291                 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
2292                 red->t140.datalen += frame->datalen;
2293                 red->t140.ts = frame->ts;
2294         }
2295
2296         return 0;
2297 }
2298
2299 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
2300 {
2301         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
2302
2303         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2304
2305         return 0;
2306 }
2307
2308 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
2309 {
2310         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2311
2312         if (!rtp->rtcp) {
2313                 return -1;
2314         }
2315
2316         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
2317         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
2318
2319         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
2320         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);
2321         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
2322         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
2323         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lost);
2324         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_stdevrxploss, rtp->rtcp->reported_stdev_lost);
2325         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_maxrxploss, rtp->rtcp->maxrxlost);
2326         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_minrxploss, rtp->rtcp->minrxlost);
2327         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_normdevrxploss, rtp->rtcp->normdev_rxlost);
2328         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_stdevrxploss, rtp->rtcp->stdev_rxlost);
2329         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_LOSS);
2330
2331         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->txjitter, rtp->rxjitter);
2332         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);
2333         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_maxjitter, rtp->rtcp->reported_maxjitter);
2334         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_minjitter, rtp->rtcp->reported_minjitter);
2335         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_normdevjitter, rtp->rtcp->reported_normdev_jitter);
2336         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_stdevjitter, rtp->rtcp->reported_stdev_jitter);
2337         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_maxjitter, rtp->rtcp->maxrxjitter);
2338         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_minjitter, rtp->rtcp->minrxjitter);
2339         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_normdevjitter, rtp->rtcp->normdev_rxjitter);
2340         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_stdevjitter, rtp->rtcp->stdev_rxjitter);
2341         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_JITTER);
2342
2343         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->rtt, rtp->rtcp->rtt);
2344         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MAX_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->maxrtt, rtp->rtcp->maxrtt);
2345         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MIN_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->minrtt, rtp->rtcp->minrtt);
2346         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_NORMDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->normdevrtt, rtp->rtcp->normdevrtt);
2347         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_STDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->stdevrtt, rtp->rtcp->stdevrtt);
2348         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_RTT);
2349
2350         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_SSRC, -1, stats->local_ssrc, rtp->ssrc);
2351         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_SSRC, -1, stats->remote_ssrc, rtp->themssrc);
2352
2353         return 0;
2354 }
2355
2356 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
2357 {
2358         /* If both sides are not using the same method of DTMF transmission
2359          * (ie: one is RFC2833, other is INFO... then we can not do direct media.
2360          * --------------------------------------------------
2361          * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
2362          * |-----------|------------|-----------------------|
2363          * | Inband    | False      | True                  |
2364          * | RFC2833   | True       | True                  |
2365          * | SIP INFO  | False      | False                 |
2366          * --------------------------------------------------
2367          */
2368         return (((ast_rtp_instance_get_prop(instance0, AST_RTP_PROPERTY_DTMF) != ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_DTMF)) ||
2369                  (!chan0->tech->send_digit_begin != !chan1->tech->send_digit_begin)) ? 0 : 1);
2370 }
2371
2372 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct sockaddr_in *suggestion, const char *username)
2373 {
2374         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2375
2376         ast_stun_request(rtp->s, suggestion, username, NULL);
2377 }
2378
2379 static void ast_rtp_stop(struct ast_rtp_instance *instance)
2380 {
2381         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2382         struct sockaddr_in sin = { 0, };
2383
2384         if (rtp->rtcp) {
2385                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2386         }
2387         if (rtp->red) {
2388                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2389                 free(rtp->red);
2390                 rtp->red = NULL;
2391         }
2392
2393         ast_rtp_instance_set_remote_address(instance, &sin);
2394         if (rtp->rtcp) {
2395                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2396                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2397         }
2398
2399         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2400 }
2401
2402 static char *rtp_do_debug_ip(struct ast_cli_args *a)
2403 {
2404         struct hostent *hp;
2405         struct ast_hostent ahp;
2406         int port = 0;
2407         char *p, *arg = ast_strdupa(a->argv[4]);
2408
2409         p = strstr(arg, ":");
2410         if (p) {
2411                 *p = '\0';
2412                 p++;
2413                 port = atoi(p);
2414         }
2415         hp = ast_gethostbyname(arg, &ahp);
2416         if (hp == NULL) {
2417                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2418                 return CLI_FAILURE;
2419         }
2420         rtpdebugaddr.sin_family = AF_INET;
2421         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
2422         rtpdebugaddr.sin_port = htons(port);
2423         if (port == 0)
2424                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
2425         else
2426                 ast_cli(a->fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
2427         rtpdebug = 1;
2428         return CLI_SUCCESS;
2429 }
2430
2431 static char *rtcp_do_debug_ip(struct ast_cli_args *a)
2432 {
2433         struct hostent *hp;
2434         struct ast_hostent ahp;
2435         int port = 0;
2436         char *p, *arg = ast_strdupa(a->argv[3]);
2437
2438         p = strstr(arg, ":");
2439         if (p) {
2440                 *p = '\0';
2441                 p++;
2442                 port = atoi(p);
2443         }
2444         hp = ast_gethostbyname(arg, &ahp);
2445         if (hp == NULL) {
2446                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2447                 return CLI_FAILURE;
2448         }
2449         rtcpdebugaddr.sin_family = AF_INET;
2450         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
2451         rtcpdebugaddr.sin_port = htons(port);
2452         if (port == 0)
2453                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
2454         else
2455                 ast_cli(a->fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
2456         rtcpdebug = 1;
2457         return CLI_SUCCESS;
2458 }
2459
2460 static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2461 {
2462         switch (cmd) {
2463         case CLI_INIT:
2464                 e->command = "rtp set debug {on|off|ip}";
2465                 e->usage =
2466                         "Usage: rtp set debug {on|off|ip host[:port]}\n"
2467                         "       Enable/Disable dumping of all RTP packets. If 'ip' is\n"
2468                         "       specified, limit the dumped packets to those to and from\n"
2469                         "       the specified 'host' with optional port.\n";
2470                 return NULL;
2471         case CLI_GENERATE:
2472                 return NULL;
2473         }
2474
2475         if (a->argc == e->args) { /* set on or off */
2476                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2477                         rtpdebug = 1;
2478                         memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
2479                         ast_cli(a->fd, "RTP Debugging Enabled\n");
2480                         return CLI_SUCCESS;
2481                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2482                         rtpdebug = 0;
2483                         ast_cli(a->fd, "RTP Debugging Disabled\n");
2484                         return CLI_SUCCESS;
2485                 }
2486         } else if (a->argc == e->args +1) { /* ip */
2487                 return rtp_do_debug_ip(a);
2488         }
2489
2490         return CLI_SHOWUSAGE;   /* default, failure */
2491 }
2492
2493 static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2494 {
2495         switch (cmd) {
2496         case CLI_INIT:
2497                 e->command = "rtcp set debug {on|off|ip}";
2498                 e->usage =
2499                         "Usage: rtcp set debug {on|off|ip host[:port]}\n"
2500                         "       Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
2501                         "       specified, limit the dumped packets to those to and from\n"
2502                         "       the specified 'host' with optional port.\n";
2503                 return NULL;
2504         case CLI_GENERATE:
2505                 return NULL;
2506         }
2507
2508         if (a->argc == e->args) { /* set on or off */
2509                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2510                         rtcpdebug = 1;
2511                         memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
2512                         ast_cli(a->fd, "RTCP Debugging Enabled\n");
2513                         return CLI_SUCCESS;
2514                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2515                         rtcpdebug = 0;
2516                         ast_cli(a->fd, "RTCP Debugging Disabled\n");
2517                         return CLI_SUCCESS;
2518                 }
2519         } else if (a->argc == e->args +1) { /* ip */
2520                 return rtcp_do_debug_ip(a);
2521         }
2522
2523         return CLI_SHOWUSAGE;   /* default, failure */
2524 }
2525
2526 static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2527 {
2528         switch (cmd) {
2529         case CLI_INIT:
2530                 e->command = "rtcp set stats {on|off}";
2531                 e->usage =
2532                         "Usage: rtcp set stats {on|off}\n"
2533                         "       Enable/Disable dumping of RTCP stats.\n";
2534                 return NULL;
2535         case CLI_GENERATE:
2536                 return NULL;
2537         }
2538
2539         if (a->argc != e->args)
2540                 return CLI_SHOWUSAGE;
2541
2542         if (!strncasecmp(a->argv[e->args-1], "on", 2))
2543                 rtcpstats = 1;
2544         else if (!strncasecmp(a->argv[e->args-1], "off", 3))
2545                 rtcpstats = 0;
2546         else
2547                 return CLI_SHOWUSAGE;
2548
2549         ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
2550         return CLI_SUCCESS;
2551 }
2552
2553 static struct ast_cli_entry cli_rtp[] = {
2554         AST_CLI_DEFINE(handle_cli_rtp_set_debug,  "Enable/Disable RTP debugging"),
2555         AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
2556         AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
2557 };
2558
2559 static int rtp_reload(int reload)
2560 {
2561         struct ast_config *cfg;
2562         const char *s;
2563         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
2564
2565         cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
2566         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
2567                 return 0;
2568         }
2569
2570         rtpstart = DEFAULT_RTP_START;
2571         rtpend = DEFAULT_RTP_END;
2572         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2573         strictrtp = STRICT_RTP_OPEN;
2574         if (cfg) {
2575                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2576                         rtpstart = atoi(s);
2577                         if (rtpstart < MINIMUM_RTP_PORT)
2578                                 rtpstart = MINIMUM_RTP_PORT;
2579                         if (rtpstart > MAXIMUM_RTP_PORT)
2580                                 rtpstart = MAXIMUM_RTP_PORT;
2581                 }
2582                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2583                         rtpend = atoi(s);
2584                         if (rtpend < MINIMUM_RTP_PORT)
2585                                 rtpend = MINIMUM_RTP_PORT;
2586                         if (rtpend > MAXIMUM_RTP_PORT)
2587                                 rtpend = MAXIMUM_RTP_PORT;
2588                 }
2589                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
2590                         rtcpinterval = atoi(s);
2591                         if (rtcpinterval == 0)
2592                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
2593                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
2594                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
2595                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
2596                                 rtcpinterval = RTCP_MAX_INTERVALMS;
2597                 }
2598                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2599 #ifdef SO_NO_CHECK
2600                         nochecksums = ast_false(s) ? 1 : 0;
2601 #else
2602                         if (ast_false(s))
2603                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2604 #endif
2605                 }
2606                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2607                         dtmftimeout = atoi(s);
2608                         if ((dtmftimeout < 0) || (dtmftimeout > 64000)) {
2609                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2610                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2611                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2612                         };
2613                 }
2614                 if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
2615                         strictrtp = ast_true(s);
2616                 }
2617                 ast_config_destroy(cfg);
2618         }
2619         if (rtpstart >= rtpend) {
2620                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2621                 rtpstart = DEFAULT_RTP_START;
2622                 rtpend = DEFAULT_RTP_END;
2623         }
2624         ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2625         return 0;
2626 }
2627
2628 static int reload_module(void)
2629 {
2630         rtp_reload(1);
2631         return 0;
2632 }
2633
2634 static int load_module(void)
2635 {
2636         if (ast_rtp_engine_register(&asterisk_rtp_engine)) {
2637                 return AST_MODULE_LOAD_DECLINE;
2638         }
2639
2640         if (ast_cli_register_multiple(cli_rtp, ARRAY_LEN(cli_rtp))) {
2641                 ast_rtp_engine_unregister(&asterisk_rtp_engine);
2642                 return AST_MODULE_LOAD_DECLINE;
2643         }
2644
2645         rtp_reload(0);
2646
2647         return AST_MODULE_LOAD_SUCCESS;
2648 }
2649
2650 static int unload_module(void)
2651 {
2652         ast_rtp_engine_unregister(&asterisk_rtp_engine);
2653         ast_cli_unregister_multiple(cli_rtp, ARRAY_LEN(cli_rtp));
2654
2655         return 0;
2656 }
2657
2658 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Asterisk RTP Stack",
2659                 .load = load_module,
2660                 .unload = unload_module,
2661                 .reload = reload_module,
2662                 );