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