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