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