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