Merged revisions 290542 via svnmerge from
[asterisk/asterisk.git] / res / res_rtp_asterisk.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  *
26  * \note RTP is defined in RFC 3550.
27  *
28  * \ingroup rtp_engines
29  */
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include <sys/time.h>
36 #include <signal.h>
37 #include <fcntl.h>
38
39 #include "asterisk/stun.h"
40 #include "asterisk/pbx.h"
41 #include "asterisk/frame.h"
42 #include "asterisk/channel.h"
43 #include "asterisk/acl.h"
44 #include "asterisk/config.h"
45 #include "asterisk/lock.h"
46 #include "asterisk/utils.h"
47 #include "asterisk/cli.h"
48 #include "asterisk/manager.h"
49 #include "asterisk/unaligned.h"
50 #include "asterisk/module.h"
51 #include "asterisk/rtp_engine.h"
52
53 #define MAX_TIMESTAMP_SKEW      640
54
55 #define RTP_SEQ_MOD     (1<<16) /*!< A sequence number can't be more than 16 bits */
56 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
57 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
58 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
59
60 #define DEFAULT_RTP_START 5000 /*!< Default port number to start allocating RTP ports from */
61 #define DEFAULT_RTP_END 31000  /*!< Default maximum port number to end allocating RTP ports at */
62
63 #define MINIMUM_RTP_PORT 1024 /*!< Minimum port number to accept */
64 #define MAXIMUM_RTP_PORT 65535 /*!< Maximum port number to accept */
65
66 #define RTCP_PT_FUR     192
67 #define RTCP_PT_SR      200
68 #define RTCP_PT_RR      201
69 #define RTCP_PT_SDES    202
70 #define RTCP_PT_BYE     203
71 #define RTCP_PT_APP     204
72
73 #define RTP_MTU         1200
74
75 #define DEFAULT_DTMF_TIMEOUT (150 * (8000 / 1000))      /*!< samples */
76
77 #define ZFONE_PROFILE_ID 0x505a
78
79 extern struct ast_srtp_res *res_srtp;
80 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
81
82 static int rtpstart = DEFAULT_RTP_START;                        /*!< First port for RTP sessions (set in rtp.conf) */
83 static int rtpend = DEFAULT_RTP_END;                    /*!< Last port for RTP sessions (set in rtp.conf) */
84 static int rtpdebug;                    /*!< Are we debugging? */
85 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
86 static int rtcpstats;                   /*!< Are we debugging RTCP? */
87 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
88 static struct ast_sockaddr rtpdebugaddr;        /*!< Debug packets to/from this host */
89 static struct ast_sockaddr rtcpdebugaddr;       /*!< Debug RTCP packets to/from this host */
90 #ifdef SO_NO_CHECK
91 static int nochecksums;
92 #endif
93 static int strictrtp;
94
95 enum strict_rtp_state {
96         STRICT_RTP_OPEN = 0, /*! No RTP packets should be dropped, all sources accepted */
97         STRICT_RTP_LEARN,    /*! Accept next packet as source */
98         STRICT_RTP_CLOSED,   /*! Drop all RTP packets not coming from source that was learned */
99 };
100
101 #define FLAG_3389_WARNING               (1 << 0)
102 #define FLAG_NAT_ACTIVE                 (3 << 1)
103 #define FLAG_NAT_INACTIVE               (0 << 1)
104 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
105 #define FLAG_NEED_MARKER_BIT            (1 << 3)
106 #define FLAG_DTMF_COMPENSATE            (1 << 4)
107
108 /*! \brief RTP session description */
109 struct ast_rtp {
110         int s;
111         struct ast_frame f;
112         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
113         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
114         unsigned int themssrc;          /*!< Their SSRC */
115         unsigned int rxssrc;
116         unsigned int lastts;
117         unsigned int lastrxts;
118         unsigned int lastividtimestamp;
119         unsigned int lastovidtimestamp;
120         unsigned int lastitexttimestamp;
121         unsigned int lastotexttimestamp;
122         unsigned int lasteventseqn;
123         int lastrxseqno;                /*!< Last received sequence number */
124         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
125         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
126         unsigned int rxcount;           /*!< How many packets have we received? */
127         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
128         unsigned int txcount;           /*!< How many packets have we sent? */
129         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
130         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
131         double rxjitter;                /*!< Interarrival jitter at the moment */
132         double rxtransit;               /*!< Relative transit time for previous packet */
133         format_t lasttxformat;
134         format_t lastrxformat;
135
136         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
137         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
138         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
139
140         /* DTMF Reception Variables */
141         char resp;
142         unsigned int lastevent;
143         unsigned int dtmf_duration;     /*!< Total duration in samples since the digit start event */
144         unsigned int dtmf_timeout;      /*!< When this timestamp is reached we consider END frame lost and forcibly abort digit */
145         unsigned int dtmfsamples;
146         /* DTMF Transmission Variables */
147         unsigned int lastdigitts;
148         char sending_digit;     /*!< boolean - are we sending digits */
149         char send_digit;        /*!< digit we are sending */
150         int send_payload;
151         int send_duration;
152         unsigned int flags;
153         struct timeval rxcore;
154         struct timeval txcore;
155         double drxcore;                 /*!< The double representation of the first received packet */
156         struct timeval lastrx;          /*!< timeval when we last received a packet */
157         struct timeval dtmfmute;
158         struct ast_smoother *smoother;
159         int *ioid;
160         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
161         unsigned short rxseqno;
162         struct sched_context *sched;
163         struct io_context *io;
164         void *data;
165         struct ast_rtcp *rtcp;
166         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
167
168         enum strict_rtp_state strict_rtp_state; /*!< Current state that strict RTP protection is in */
169         struct ast_sockaddr strict_rtp_address;  /*!< Remote address information for strict RTP purposes */
170         struct ast_sockaddr alt_rtp_address; /*!<Alternate remote address information */
171
172         struct rtp_red *red;
173 };
174
175 /*!
176  * \brief Structure defining an RTCP session.
177  *
178  * The concept "RTCP session" is not defined in RFC 3550, but since
179  * this structure is analogous to ast_rtp, which tracks a RTP session,
180  * it is logical to think of this as a RTCP session.
181  *
182  * RTCP packet is defined on page 9 of RFC 3550.
183  *
184  */
185 struct ast_rtcp {
186         int rtcp_info;
187         int s;                          /*!< Socket */
188         struct ast_sockaddr us;         /*!< Socket representation of the local endpoint. */
189         struct ast_sockaddr them;       /*!< Socket representation of the remote endpoint. */
190         unsigned int soc;               /*!< What they told us */
191         unsigned int spc;               /*!< What they told us */
192         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
193         struct timeval rxlsr;           /*!< Time when we got their last SR */
194         struct timeval txlsr;           /*!< Time when we sent or last SR*/
195         unsigned int expected_prior;    /*!< no. packets in previous interval */
196         unsigned int received_prior;    /*!< no. packets received in previous interval */
197         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
198         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
199         unsigned int sr_count;          /*!< number of SRs we've sent */
200         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
201         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
202         double rtt;                     /*!< Last reported rtt */
203         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
204         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
205
206         double reported_maxjitter;
207         double reported_minjitter;
208         double reported_normdev_jitter;
209         double reported_stdev_jitter;
210         unsigned int reported_jitter_count;
211
212         double reported_maxlost;
213         double reported_minlost;
214         double reported_normdev_lost;
215         double reported_stdev_lost;
216
217         double rxlost;
218         double maxrxlost;
219         double minrxlost;
220         double normdev_rxlost;
221         double stdev_rxlost;
222         unsigned int rxlost_count;
223
224         double maxrxjitter;
225         double minrxjitter;
226         double normdev_rxjitter;
227         double stdev_rxjitter;
228         unsigned int rxjitter_count;
229         double maxrtt;
230         double minrtt;
231         double normdevrtt;
232         double stdevrtt;
233         unsigned int rtt_count;
234 };
235
236 struct rtp_red {
237         struct ast_frame t140;  /*!< Primary data  */
238         struct ast_frame t140red;   /*!< Redundant t140*/
239         unsigned char pt[AST_RED_MAX_GENERATION];  /*!< Payload types for redundancy data */
240         unsigned char ts[AST_RED_MAX_GENERATION]; /*!< Time stamps */
241         unsigned char len[AST_RED_MAX_GENERATION]; /*!< length of each generation */
242         int num_gen; /*!< Number of generations */
243         int schedid; /*!< Timer id */
244         int ti; /*!< How long to buffer data before send */
245         unsigned char t140red_data[64000];
246         unsigned char buf_data[64000]; /*!< buffered primary data */
247         int hdrlen;
248         long int prev_ts;
249 };
250
251 AST_LIST_HEAD_NOLOCK(frame_list, ast_frame);
252
253 /* Forward Declarations */
254 static int ast_rtp_new(struct ast_rtp_instance *instance, struct sched_context *sched, struct ast_sockaddr *addr, void *data);
255 static int ast_rtp_destroy(struct ast_rtp_instance *instance);
256 static int ast_rtp_dtmf_begin(struct ast_rtp_instance *instance, char digit);
257 static int ast_rtp_dtmf_end(struct ast_rtp_instance *instance, char digit);
258 static 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(format_t subclass)
372 {
373         return (subclass == AST_FORMAT_G722) ? 8000 : ast_format_rate(subclass);
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 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, 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.codec) / 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.codec) / 1000;
1041
1042         if (frame->subclass.codec == 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 = frame->subclass.codec & 0x1;
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 (option_debug || 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         format_t codec, subclass;
1199
1200         ast_rtp_instance_get_remote_address(instance, &remote_address);
1201
1202         /* If we don't actually know the remote address don't even bother doing anything */
1203         if (ast_sockaddr_isnull(&remote_address)) {
1204                 ast_debug(1, "No remote address on RTP instance '%p' so dropping frame\n", instance);
1205                 return 0;
1206         }
1207
1208         /* If there is no data length we can't very well send the packet */
1209         if (!frame->datalen) {
1210                 ast_debug(1, "Received frame with no data for RTP instance '%p' so dropping frame\n", instance);
1211                 return 0;
1212         }
1213
1214         /* If the packet is not one our RTP stack supports bail out */
1215         if (frame->frametype != AST_FRAME_VOICE && frame->frametype != AST_FRAME_VIDEO && frame->frametype != AST_FRAME_TEXT) {
1216                 ast_log(LOG_WARNING, "RTP can only send voice, video, and text\n");
1217                 return -1;
1218         }
1219
1220         if (rtp->red) {
1221                 /* return 0; */
1222                 /* no primary data or generations to send */
1223                 if ((frame = red_t140_to_red(rtp->red)) == NULL)
1224                         return 0;
1225         }
1226
1227         /* Grab the subclass and look up the payload we are going to use */
1228         subclass = frame->subclass.codec;
1229         if (frame->frametype == AST_FRAME_VIDEO) {
1230                 subclass &= ~0x1LL;
1231         }
1232         if ((codec = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance), 1, subclass)) < 0) {
1233                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(frame->subclass.codec));
1234                 return -1;
1235         }
1236
1237         /* Oh dear, if the format changed we will have to set up a new smoother */
1238         if (rtp->lasttxformat != subclass) {
1239                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1240                 rtp->lasttxformat = subclass;
1241                 if (rtp->smoother) {
1242                         ast_smoother_free(rtp->smoother);
1243                         rtp->smoother = NULL;
1244                 }
1245         }
1246
1247         /* If no smoother is present see if we have to set one up */
1248         if (!rtp->smoother) {
1249                 struct ast_format_list fmt = ast_codec_pref_getsize(&ast_rtp_instance_get_codecs(instance)->pref, subclass);
1250
1251                 switch (subclass) {
1252                 case AST_FORMAT_SPEEX:
1253                 case AST_FORMAT_SPEEX16:
1254                 case AST_FORMAT_G723_1:
1255                 case AST_FORMAT_SIREN7:
1256                 case AST_FORMAT_SIREN14:
1257                 case AST_FORMAT_G719:
1258                         /* these are all frame-based codecs and cannot be safely run through
1259                            a smoother */
1260                         break;
1261                 default:
1262                         if (fmt.inc_ms) {
1263                                 if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
1264                                         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));
1265                                         return -1;
1266                                 }
1267                                 if (fmt.flags) {
1268                                         ast_smoother_set_flags(rtp->smoother, fmt.flags);
1269                                 }
1270                                 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));
1271                         }
1272                 }
1273         }
1274
1275         /* Feed audio frames into the actual function that will create a frame and send it */
1276         if (rtp->smoother) {
1277                 struct ast_frame *f;
1278
1279                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
1280                         ast_smoother_feed_be(rtp->smoother, frame);
1281                 } else {
1282                         ast_smoother_feed(rtp->smoother, frame);
1283                 }
1284
1285                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
1286                                 ast_rtp_raw_write(instance, f, codec);
1287                 }
1288         } else {
1289                 int hdrlen = 12;
1290                 struct ast_frame *f = NULL;
1291
1292                 if (frame->offset < hdrlen) {
1293                         f = ast_frdup(frame);
1294                 } else {
1295                         f = frame;
1296                 }
1297                 if (f->data.ptr) {
1298                         ast_rtp_raw_write(instance, f, codec);
1299                 }
1300                 if (f != frame) {
1301                         ast_frfree(f);
1302                 }
1303
1304         }
1305
1306         return 0;
1307 }
1308
1309 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1310 {
1311         struct timeval now;
1312         struct timeval tmp;
1313         double transit;
1314         double current_time;
1315         double d;
1316         double dtv;
1317         double prog;
1318         int rate = rtp_get_rate(rtp->f.subclass.codec);
1319
1320         double normdev_rxjitter_current;
1321         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1322                 gettimeofday(&rtp->rxcore, NULL);
1323                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1324                 /* map timestamp to a real time */
1325                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1326                 tmp = ast_samp2tv(timestamp, rate);
1327                 rtp->rxcore = ast_tvsub(rtp->rxcore, tmp);
1328                 /* Round to 0.1ms for nice, pretty timestamps */
1329                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1330         }
1331
1332         gettimeofday(&now,NULL);
1333         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1334         tmp = ast_samp2tv(timestamp, rate);
1335         *tv = ast_tvadd(rtp->rxcore, tmp);
1336
1337         prog = (double)((timestamp-rtp->seedrxts)/(float)(rate));
1338         dtv = (double)rtp->drxcore + (double)(prog);
1339         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1340         transit = current_time - dtv;
1341         d = transit - rtp->rxtransit;
1342         rtp->rxtransit = transit;
1343         if (d<0)
1344                 d=-d;
1345         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1346
1347         if (rtp->rtcp) {
1348                 if (rtp->rxjitter > rtp->rtcp->maxrxjitter)
1349                         rtp->rtcp->maxrxjitter = rtp->rxjitter;
1350                 if (rtp->rtcp->rxjitter_count == 1)
1351                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1352                 if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1353                         rtp->rtcp->minrxjitter = rtp->rxjitter;
1354
1355                 normdev_rxjitter_current = normdev_compute(rtp->rtcp->normdev_rxjitter,rtp->rxjitter,rtp->rtcp->rxjitter_count);
1356                 rtp->rtcp->stdev_rxjitter = stddev_compute(rtp->rtcp->stdev_rxjitter,rtp->rxjitter,rtp->rtcp->normdev_rxjitter,normdev_rxjitter_current,rtp->rtcp->rxjitter_count);
1357
1358                 rtp->rtcp->normdev_rxjitter = normdev_rxjitter_current;
1359                 rtp->rtcp->rxjitter_count++;
1360         }
1361 }
1362
1363 static struct ast_frame *create_dtmf_frame(struct ast_rtp_instance *instance, enum ast_frame_type type, int compensate)
1364 {
1365         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1366         struct ast_sockaddr remote_address = { {0,} };
1367
1368         ast_rtp_instance_get_remote_address(instance, &remote_address);
1369
1370         if (((compensate && type == AST_FRAME_DTMF_END) || (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
1371                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n",
1372                           ast_sockaddr_stringify(&remote_address));
1373                 rtp->resp = 0;
1374                 rtp->dtmfsamples = 0;
1375                 return &ast_null_frame;
1376         }
1377         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp,
1378                   ast_sockaddr_stringify(&remote_address));
1379         if (rtp->resp == 'X') {
1380                 rtp->f.frametype = AST_FRAME_CONTROL;
1381                 rtp->f.subclass.integer = AST_CONTROL_FLASH;
1382         } else {
1383                 rtp->f.frametype = type;
1384                 rtp->f.subclass.integer = rtp->resp;
1385         }
1386         rtp->f.datalen = 0;
1387         rtp->f.samples = 0;
1388         rtp->f.mallocd = 0;
1389         rtp->f.src = "RTP";
1390         AST_LIST_NEXT(&rtp->f, frame_list) = NULL;
1391
1392         return &rtp->f;
1393 }
1394
1395 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)
1396 {
1397         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1398         struct ast_sockaddr remote_address = { {0,} };
1399         unsigned int event, event_end, samples;
1400         char resp = 0;
1401         struct ast_frame *f = NULL;
1402
1403         ast_rtp_instance_get_remote_address(instance, &remote_address);
1404
1405         /* Figure out event, event end, and samples */
1406         event = ntohl(*((unsigned int *)(data)));
1407         event >>= 24;
1408         event_end = ntohl(*((unsigned int *)(data)));
1409         event_end <<= 8;
1410         event_end >>= 24;
1411         samples = ntohl(*((unsigned int *)(data)));
1412         samples &= 0xFFFF;
1413
1414         if (rtp_debug_test_addr(&remote_address)) {
1415                 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",
1416                             ast_sockaddr_stringify(&remote_address),
1417                             payloadtype, seqno, timestamp, len, (mark?1:0), event, ((event_end & 0x80)?1:0), samples);
1418         }
1419
1420         /* Print out debug if turned on */
1421         if (rtpdebug || option_debug > 2)
1422                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
1423
1424         /* Figure out what digit was pressed */
1425         if (event < 10) {
1426                 resp = '0' + event;
1427         } else if (event < 11) {
1428                 resp = '*';
1429         } else if (event < 12) {
1430                 resp = '#';
1431         } else if (event < 16) {
1432                 resp = 'A' + (event - 12);
1433         } else if (event < 17) {        /* Event 16: Hook flash */
1434                 resp = 'X';
1435         } else {
1436                 /* Not a supported event */
1437                 ast_log(LOG_DEBUG, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event);
1438                 return;
1439         }
1440
1441         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1442                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
1443                         rtp->resp = resp;
1444                         rtp->dtmf_timeout = 0;
1445                         f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)));
1446                         f->len = 0;
1447                         rtp->lastevent = timestamp;
1448                         AST_LIST_INSERT_TAIL(frames, f, frame_list);
1449                 }
1450         } else {
1451                 /*  The duration parameter measures the complete
1452                     duration of the event (from the beginning) - RFC2833.
1453                     Account for the fact that duration is only 16 bits long
1454                     (about 8 seconds at 8000 Hz) and can wrap is digit
1455                     is hold for too long. */
1456                 unsigned int new_duration = rtp->dtmf_duration;
1457                 unsigned int last_duration = new_duration & 0xFFFF;
1458
1459                 if (last_duration > 64000 && samples < last_duration) {
1460                         new_duration += 0xFFFF + 1;
1461                 }
1462                 new_duration = (new_duration & ~0xFFFF) | samples;
1463
1464                 /* The second portion of this check is to not mistakenly
1465                  * stop accepting DTMF if the seqno rolls over beyond
1466                  * 65535.
1467                  */
1468                 if (rtp->lastevent > seqno && rtp->lastevent - seqno < 50) {
1469                         /* Out of order frame. Processing this can cause us to
1470                          * improperly duplicate incoming DTMF, so just drop
1471                          * this.
1472                          */
1473                         return;
1474                 }
1475
1476                 if (event_end & 0x80) {
1477                         /* End event */
1478                         if ((rtp->lastevent != seqno) && rtp->resp) {
1479                                 rtp->dtmf_duration = new_duration;
1480                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
1481                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
1482                                 rtp->resp = 0;
1483                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1484                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
1485                         }
1486                 } else {
1487                         /* Begin/continuation */
1488
1489                         if (rtp->resp && rtp->resp != resp) {
1490                                 /* Another digit already began. End it */
1491                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0));
1492                                 f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
1493                                 rtp->resp = 0;
1494                                 rtp->dtmf_duration = rtp->dtmf_timeout = 0;
1495                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
1496                         }
1497
1498                         if (rtp->resp) {
1499                                 /* Digit continues */
1500                                 rtp->dtmf_duration = new_duration;
1501                         } else {
1502                                 /* New digit began */
1503                                 rtp->resp = resp;
1504                                 f = ast_frdup(create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0));
1505                                 rtp->dtmf_duration = samples;
1506                                 AST_LIST_INSERT_TAIL(frames, f, frame_list);
1507                         }
1508
1509                         rtp->dtmf_timeout = timestamp + rtp->dtmf_duration + dtmftimeout;
1510                 }
1511
1512                 rtp->lastevent = seqno;
1513         }
1514
1515         rtp->dtmfsamples = samples;
1516
1517         return;
1518 }
1519
1520 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)
1521 {
1522         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1523         unsigned int event, flags, power;
1524         char resp = 0;
1525         unsigned char seq;
1526         struct ast_frame *f = NULL;
1527
1528         if (len < 4) {
1529                 return NULL;
1530         }
1531
1532         /*      The format of Cisco RTP DTMF packet looks like next:
1533                 +0                              - sequence number of DTMF RTP packet (begins from 1,
1534                                                   wrapped to 0)
1535                 +1                              - set of flags
1536                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
1537                                                   or repeated digit without audio???
1538                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
1539                                                   then falls to 0 at its end)
1540                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
1541                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
1542                 by each new packet and thus provides some redudancy.
1543
1544                 Sample of Cisco RTP DTMF packet is (all data in hex):
1545                         19 07 00 02 12 02 20 02
1546                 showing end of DTMF digit '2'.
1547
1548                 The packets
1549                         27 07 00 02 0A 02 20 02
1550                         28 06 20 02 00 02 0A 02
1551                 shows begin of new digit '2' with very short pause (20 ms) after
1552                 previous digit '2'. Bit +1.0 flips at begin of new digit.
1553
1554                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
1555                 so its uses the same sequencing and timestamping rules as replaced
1556                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
1557                 on audio framing parameters. Marker bit isn't used within stream of
1558                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
1559                 are not sequential at borders between DTMF and audio streams,
1560         */
1561
1562         seq = data[0];
1563         flags = data[1];
1564         power = data[2];
1565         event = data[3] & 0x1f;
1566
1567         if (option_debug > 2 || rtpdebug)
1568                 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);
1569         if (event < 10) {
1570                 resp = '0' + event;
1571         } else if (event < 11) {
1572                 resp = '*';
1573         } else if (event < 12) {
1574                 resp = '#';
1575         } else if (event < 16) {
1576                 resp = 'A' + (event - 12);
1577         } else if (event < 17) {
1578                 resp = 'X';
1579         }
1580         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
1581                 rtp->resp = resp;
1582                 /* Why we should care on DTMF compensation at reception? */
1583                 if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE)) {
1584                         f = create_dtmf_frame(instance, AST_FRAME_DTMF_BEGIN, 0);
1585                         rtp->dtmfsamples = 0;
1586                 }
1587         } else if ((rtp->resp == resp) && !power) {
1588                 f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_DTMF_COMPENSATE));
1589                 f->samples = rtp->dtmfsamples * (rtp->lastrxformat ? (rtp_get_rate(rtp->lastrxformat) / 1000) : 8);
1590                 rtp->resp = 0;
1591         } else if (rtp->resp == resp)
1592                 rtp->dtmfsamples += 20 * (rtp->lastrxformat ? (rtp_get_rate(rtp->lastrxformat) / 1000) : 8);
1593
1594         rtp->dtmf_timeout = 0;
1595
1596         return f;
1597 }
1598
1599 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)
1600 {
1601         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1602
1603         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
1604            totally help us out becuase we don't have an engine to keep it going and we are not
1605            guaranteed to have it every 20ms or anything */
1606         if (rtpdebug)
1607                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %" PRId64 " (len = %d)\n", rtp->lastrxformat, len);
1608
1609         if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
1610                 struct ast_sockaddr remote_address = { {0,} };
1611
1612                 ast_rtp_instance_get_remote_address(instance, &remote_address);
1613
1614                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client address: %s\n",
1615                         ast_sockaddr_stringify(&remote_address));
1616                 ast_set_flag(rtp, FLAG_3389_WARNING);
1617         }
1618
1619         /* Must have at least one byte */
1620         if (!len)
1621                 return NULL;
1622         if (len < 24) {
1623                 rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
1624                 rtp->f.datalen = len - 1;
1625                 rtp->f.offset = AST_FRIENDLY_OFFSET;
1626                 memcpy(rtp->f.data.ptr, data + 1, len - 1);
1627         } else {
1628                 rtp->f.data.ptr = NULL;
1629                 rtp->f.offset = 0;
1630                 rtp->f.datalen = 0;
1631         }
1632         rtp->f.frametype = AST_FRAME_CNG;
1633         rtp->f.subclass.integer = data[0] & 0x7f;
1634         rtp->f.samples = 0;
1635         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
1636
1637         return &rtp->f;
1638 }
1639
1640 static struct ast_frame *ast_rtcp_read(struct ast_rtp_instance *instance)
1641 {
1642         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1643         struct ast_sockaddr addr;
1644         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
1645         unsigned int *rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
1646         int res, packetwords, position = 0;
1647         struct ast_frame *f = &ast_null_frame;
1648
1649         /* Read in RTCP data from the socket */
1650         if ((res = rtcp_recvfrom(instance, rtcpdata + AST_FRIENDLY_OFFSET,
1651                                 sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
1652                                 0, &addr)) < 0) {
1653                 ast_assert(errno != EBADF);
1654                 if (errno != EAGAIN) {
1655                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
1656                         return NULL;
1657                 }
1658                 return &ast_null_frame;
1659         }
1660
1661         packetwords = res / 4;
1662
1663         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
1664                 /* Send to whoever sent to us */
1665                 if (ast_sockaddr_cmp(&rtp->rtcp->them, &addr)) {
1666                         ast_sockaddr_copy(&rtp->rtcp->them, &addr);
1667                         if (option_debug || rtpdebug)
1668                                 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s\n",
1669                                           ast_sockaddr_stringify(&rtp->rtcp->them));
1670                 }
1671         }
1672
1673         ast_debug(1, "Got RTCP report of %d bytes\n", res);
1674
1675         while (position < packetwords) {
1676                 int i, pt, rc;
1677                 unsigned int length, dlsr, lsr, msw, lsw, comp;
1678                 struct timeval now;
1679                 double rttsec, reported_jitter, reported_normdev_jitter_current, normdevrtt_current, reported_lost, reported_normdev_lost_current;
1680                 uint64_t rtt = 0;
1681
1682                 i = position;
1683                 length = ntohl(rtcpheader[i]);
1684                 pt = (length & 0xff0000) >> 16;
1685                 rc = (length & 0x1f000000) >> 24;
1686                 length &= 0xffff;
1687
1688                 if ((i + length) > packetwords) {
1689                         if (option_debug || rtpdebug)
1690                                 ast_log(LOG_DEBUG, "RTCP Read too short\n");
1691                         return &ast_null_frame;
1692                 }
1693
1694                 if (rtcp_debug_test_addr(&addr)) {
1695                         ast_verbose("\n\nGot RTCP from %s\n",
1696                                     ast_sockaddr_stringify(&addr));
1697                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
1698                         ast_verbose("Reception reports: %d\n", rc);
1699                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
1700                 }
1701
1702                 i += 2; /* Advance past header and ssrc */
1703                 if (rc == 0 && pt == RTCP_PT_RR) {      /* We're receiving a receiver report with no reports, which is ok */
1704                         position += (length + 1);
1705                         continue;
1706                 }
1707
1708                 switch (pt) {
1709                 case RTCP_PT_SR:
1710                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
1711                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
1712                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
1713                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
1714
1715                         if (rtcp_debug_test_addr(&addr)) {
1716                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
1717                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
1718                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
1719                         }
1720                         i += 5;
1721                         if (rc < 1)
1722                                 break;
1723                         /* Intentional fall through */
1724                 case RTCP_PT_RR:
1725                         /* Don't handle multiple reception reports (rc > 1) yet */
1726                         /* Calculate RTT per RFC */
1727                         gettimeofday(&now, NULL);
1728                         timeval2ntp(now, &msw, &lsw);
1729                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
1730                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
1731                                 lsr = ntohl(rtcpheader[i + 4]);
1732                                 dlsr = ntohl(rtcpheader[i + 5]);
1733                                 rtt = comp - lsr - dlsr;
1734
1735                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
1736                                    sess->ee_delay = (eedelay * 1000) / 65536; */
1737                                 if (rtt < 4294) {
1738                                         rtt = (rtt * 1000000) >> 16;
1739                                 } else {
1740                                         rtt = (rtt * 1000) >> 16;
1741                                         rtt *= 1000;
1742                                 }
1743                                 rtt = rtt / 1000.;
1744                                 rttsec = rtt / 1000.;
1745                                 rtp->rtcp->rtt = rttsec;
1746
1747                                 if (comp - dlsr >= lsr) {
1748                                         rtp->rtcp->accumulated_transit += rttsec;
1749
1750                                         if (rtp->rtcp->rtt_count == 0)
1751                                                 rtp->rtcp->minrtt = rttsec;
1752
1753                                         if (rtp->rtcp->maxrtt<rttsec)
1754                                                 rtp->rtcp->maxrtt = rttsec;
1755                                         if (rtp->rtcp->minrtt>rttsec)
1756                                                 rtp->rtcp->minrtt = rttsec;
1757
1758                                         normdevrtt_current = normdev_compute(rtp->rtcp->normdevrtt, rttsec, rtp->rtcp->rtt_count);
1759
1760                                         rtp->rtcp->stdevrtt = stddev_compute(rtp->rtcp->stdevrtt, rttsec, rtp->rtcp->normdevrtt, normdevrtt_current, rtp->rtcp->rtt_count);
1761
1762                                         rtp->rtcp->normdevrtt = normdevrtt_current;
1763
1764                                         rtp->rtcp->rtt_count++;
1765                                 } else if (rtcp_debug_test_addr(&addr)) {
1766                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1767                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1768                                                     "diff=%d\n",
1769                                                     lsr, comp, dlsr, dlsr / 65536,
1770                                                     (dlsr % 65536) * 1000 / 65536,
1771                                                     dlsr - (comp - lsr));
1772                                 }
1773                         }
1774
1775                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1776                         reported_jitter = (double) rtp->rtcp->reported_jitter;
1777
1778                         if (rtp->rtcp->reported_jitter_count == 0)
1779                                 rtp->rtcp->reported_minjitter = reported_jitter;
1780
1781                         if (reported_jitter < rtp->rtcp->reported_minjitter)
1782                                 rtp->rtcp->reported_minjitter = reported_jitter;
1783
1784                         if (reported_jitter > rtp->rtcp->reported_maxjitter)
1785                                 rtp->rtcp->reported_maxjitter = reported_jitter;
1786
1787                         reported_normdev_jitter_current = normdev_compute(rtp->rtcp->reported_normdev_jitter, reported_jitter, rtp->rtcp->reported_jitter_count);
1788
1789                         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);
1790
1791                         rtp->rtcp->reported_normdev_jitter = reported_normdev_jitter_current;
1792
1793                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1794
1795                         reported_lost = (double) rtp->rtcp->reported_lost;
1796
1797                         /* using same counter as for jitter */
1798                         if (rtp->rtcp->reported_jitter_count == 0)
1799                                 rtp->rtcp->reported_minlost = reported_lost;
1800
1801                         if (reported_lost < rtp->rtcp->reported_minlost)
1802                                 rtp->rtcp->reported_minlost = reported_lost;
1803
1804                         if (reported_lost > rtp->rtcp->reported_maxlost)
1805                                 rtp->rtcp->reported_maxlost = reported_lost;
1806                         reported_normdev_lost_current = normdev_compute(rtp->rtcp->reported_normdev_lost, reported_lost, rtp->rtcp->reported_jitter_count);
1807
1808                         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);
1809
1810                         rtp->rtcp->reported_normdev_lost = reported_normdev_lost_current;
1811
1812                         rtp->rtcp->reported_jitter_count++;
1813
1814                         if (rtcp_debug_test_addr(&addr)) {
1815                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1816                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1817                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1818                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1819                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1820                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1821                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1822                                 if (rtt)
1823                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1824                         }
1825                         if (rtt) {
1826                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s\r\n"
1827                                                                     "PT: %d(%s)\r\n"
1828                                                                     "ReceptionReports: %d\r\n"
1829                                                                     "SenderSSRC: %u\r\n"
1830                                                                     "FractionLost: %ld\r\n"
1831                                                                     "PacketsLost: %d\r\n"
1832                                                                     "HighestSequence: %ld\r\n"
1833                                                                     "SequenceNumberCycles: %ld\r\n"
1834                                                                     "IAJitter: %u\r\n"
1835                                                                     "LastSR: %lu.%010lu\r\n"
1836                                                                     "DLSR: %4.4f(sec)\r\n"
1837                                               "RTT: %llu(sec)\r\n",
1838                                               ast_sockaddr_stringify(&addr),
1839                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1840                                               rc,
1841                                               rtcpheader[i + 1],
1842                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1843                                               rtp->rtcp->reported_lost,
1844                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1845                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1846                                               rtp->rtcp->reported_jitter,
1847                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1848                                               ntohl(rtcpheader[i + 5])/65536.0,
1849                                               (unsigned long long)rtt);
1850                         } else {
1851                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s\r\n"
1852                                                                     "PT: %d(%s)\r\n"
1853                                                                     "ReceptionReports: %d\r\n"
1854                                                                     "SenderSSRC: %u\r\n"
1855                                                                     "FractionLost: %ld\r\n"
1856                                                                     "PacketsLost: %d\r\n"
1857                                                                     "HighestSequence: %ld\r\n"
1858                                                                     "SequenceNumberCycles: %ld\r\n"
1859                                                                     "IAJitter: %u\r\n"
1860                                                                     "LastSR: %lu.%010lu\r\n"
1861                                               "DLSR: %4.4f(sec)\r\n",
1862                                               ast_sockaddr_stringify(&addr),
1863                                               pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1864                                               rc,
1865                                               rtcpheader[i + 1],
1866                                               (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1867                                               rtp->rtcp->reported_lost,
1868                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1869                                               (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1870                                               rtp->rtcp->reported_jitter,
1871                                               (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1872                                               ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1873                                               ntohl(rtcpheader[i + 5])/65536.0);
1874                         }
1875                         break;
1876                 case RTCP_PT_FUR:
1877                         if (rtcp_debug_test_addr(&addr))
1878                                 ast_verbose("Received an RTCP Fast Update Request\n");
1879                         rtp->f.frametype = AST_FRAME_CONTROL;
1880                         rtp->f.subclass.integer = AST_CONTROL_VIDUPDATE;
1881                         rtp->f.datalen = 0;
1882                         rtp->f.samples = 0;
1883                         rtp->f.mallocd = 0;
1884                         rtp->f.src = "RTP";
1885                         f = &rtp->f;
1886                         break;
1887                 case RTCP_PT_SDES:
1888                         if (rtcp_debug_test_addr(&addr))
1889                                 ast_verbose("Received an SDES from %s\n",
1890                                             ast_sockaddr_stringify(&rtp->rtcp->them));
1891                         break;
1892                 case RTCP_PT_BYE:
1893                         if (rtcp_debug_test_addr(&addr))
1894                                 ast_verbose("Received a BYE from %s\n",
1895                                             ast_sockaddr_stringify(&rtp->rtcp->them));
1896                         break;
1897                 default:
1898                         ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s\n",
1899                                   pt, ast_sockaddr_stringify(&rtp->rtcp->them));
1900                         break;
1901                 }
1902                 position += (length + 1);
1903         }
1904
1905         rtp->rtcp->rtcp_info = 1;
1906
1907         return f;
1908 }
1909
1910 static int bridge_p2p_rtp_write(struct ast_rtp_instance *instance, unsigned int *rtpheader, int len, int hdrlen)
1911 {
1912         struct ast_rtp_instance *instance1 = ast_rtp_instance_get_bridged(instance);
1913         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance), *bridged = ast_rtp_instance_get_data(instance1);
1914         int res = 0, payload = 0, bridged_payload = 0, mark;
1915         struct ast_rtp_payload_type payload_type;
1916         int reconstruct = ntohl(rtpheader[0]);
1917         struct ast_sockaddr remote_address = { {0,} };
1918
1919         /* Get fields from packet */
1920         payload = (reconstruct & 0x7f0000) >> 16;
1921         mark = (((reconstruct & 0x800000) >> 23) != 0);
1922
1923         /* Check what the payload value should be */
1924         payload_type = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payload);
1925
1926         /* Otherwise adjust bridged payload to match */
1927         bridged_payload = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(instance1), payload_type.asterisk_format, payload_type.code);
1928
1929         /* 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 */
1930         if (!(ast_rtp_instance_get_codecs(instance1)->payloads[bridged_payload].code)) {
1931                 return -1;
1932         }
1933
1934         /* If the marker bit has been explicitly set turn it on */
1935         if (ast_test_flag(rtp, FLAG_NEED_MARKER_BIT)) {
1936                 mark = 1;
1937                 ast_clear_flag(rtp, FLAG_NEED_MARKER_BIT);
1938         }
1939
1940         /* Reconstruct part of the packet */
1941         reconstruct &= 0xFF80FFFF;
1942         reconstruct |= (bridged_payload << 16);
1943         reconstruct |= (mark << 23);
1944         rtpheader[0] = htonl(reconstruct);
1945
1946         ast_rtp_instance_get_remote_address(instance1, &remote_address);
1947
1948         if (ast_sockaddr_isnull(&remote_address)) {
1949                 ast_debug(1, "Remote address is null, most likely RTP has been stopped\n");
1950                 return 0;
1951         }
1952
1953         /* Send the packet back out */
1954         res = rtp_sendto(instance1, (void *)rtpheader, len, 0, &remote_address);
1955         if (res < 0) {
1956                 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))) {
1957                         ast_log(LOG_WARNING,
1958                                 "RTP Transmission error of packet to %s: %s\n",
1959                                 ast_sockaddr_stringify(&remote_address),
1960                                 strerror(errno));
1961                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1962                         if (option_debug || rtpdebug)
1963                                 ast_log(LOG_WARNING,
1964                                         "RTP NAT: Can't write RTP to private "
1965                                         "address %s, waiting for other end to "
1966                                         "send audio...\n",
1967                                         ast_sockaddr_stringify(&remote_address));
1968                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1969                 }
1970                 return 0;
1971         } else if (rtp_debug_test_addr(&remote_address)) {
1972                 ast_verbose("Sent RTP P2P packet to %s (type %-2.2d, len %-6.6u)\n",
1973                             ast_sockaddr_stringify(&remote_address),
1974                             bridged_payload, len - hdrlen);
1975         }
1976
1977         return 0;
1978 }
1979
1980 static struct ast_frame *ast_rtp_read(struct ast_rtp_instance *instance, int rtcp)
1981 {
1982         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
1983         struct ast_sockaddr addr;
1984         int res, hdrlen = 12, version, payloadtype, padding, mark, ext, cc, prev_seqno;
1985         unsigned int *rtpheader = (unsigned int*)(rtp->rawdata + AST_FRIENDLY_OFFSET), seqno, ssrc, timestamp;
1986         struct ast_rtp_payload_type payload;
1987         struct ast_sockaddr remote_address = { {0,} };
1988         struct frame_list frames;
1989
1990         /* If this is actually RTCP let's hop on over and handle it */
1991         if (rtcp) {
1992                 if (rtp->rtcp) {
1993                         return ast_rtcp_read(instance);
1994                 }
1995                 return &ast_null_frame;
1996         }
1997
1998         /* If we are currently sending DTMF to the remote party send a continuation packet */
1999         if (rtp->sending_digit) {
2000                 ast_rtp_dtmf_continuation(instance);
2001         }
2002
2003         /* Actually read in the data from the socket */
2004         if ((res = rtp_recvfrom(instance, rtp->rawdata + AST_FRIENDLY_OFFSET,
2005                                 sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0,
2006                                 &addr)) < 0) {
2007                 ast_assert(errno != EBADF);
2008                 if (errno != EAGAIN) {
2009                         ast_log(LOG_WARNING, "RTP Read error: %s. Hanging up.\n", strerror(errno));
2010                         return NULL;
2011                 }
2012                 return &ast_null_frame;
2013         }
2014
2015         /* Make sure the data that was read in is actually enough to make up an RTP packet */
2016         if (res < hdrlen) {
2017                 ast_log(LOG_WARNING, "RTP Read too short\n");
2018                 return &ast_null_frame;
2019         }
2020
2021         /* If strict RTP protection is enabled see if we need to learn the remote address or if we need to drop the packet */
2022         if (rtp->strict_rtp_state == STRICT_RTP_LEARN) {
2023                 ast_sockaddr_copy(&rtp->strict_rtp_address, &addr);
2024                 rtp->strict_rtp_state = STRICT_RTP_CLOSED;
2025         } else if (rtp->strict_rtp_state == STRICT_RTP_CLOSED) {
2026                 if (ast_sockaddr_cmp(&rtp->strict_rtp_address, &addr)) {
2027                         /* Hmm, not the strict addres. Perhaps we're getting audio from the alternate? */
2028                         if (!ast_sockaddr_cmp(&rtp->alt_rtp_address, &addr)) {
2029                                 /* ooh, we did! You're now the new expected address, son! */
2030                                 ast_sockaddr_copy(&rtp->strict_rtp_address,
2031                                                   &addr);
2032                         } else  {
2033                                 const char *real_addr = ast_strdupa(ast_sockaddr_stringify(&addr));
2034                                 const char *expected_addr = ast_strdupa(ast_sockaddr_stringify(&rtp->strict_rtp_address));
2035
2036                                 ast_debug(1, "Received RTP packet from %s, dropping due to strict RTP protection. Expected it to be from %s\n",
2037                                                 real_addr, expected_addr);
2038
2039                                 return &ast_null_frame;
2040                         }
2041                 }
2042         }
2043
2044         /* Get fields and verify this is an RTP packet */
2045         seqno = ntohl(rtpheader[0]);
2046
2047         ast_rtp_instance_get_remote_address(instance, &remote_address);
2048
2049         if (!(version = (seqno & 0xC0000000) >> 30)) {
2050                 struct sockaddr_in addr_tmp;
2051                 ast_sockaddr_to_sin(&addr, &addr_tmp);
2052                 if ((ast_stun_handle_packet(rtp->s, &addr_tmp, rtp->rawdata + AST_FRIENDLY_OFFSET, res, NULL, NULL) == AST_STUN_ACCEPT) &&
2053                     ast_sockaddr_isnull(&remote_address)) {
2054                         ast_sockaddr_from_sin(&addr, &addr_tmp);
2055                         ast_rtp_instance_set_remote_address(instance, &addr);
2056                 }
2057                 return &ast_null_frame;
2058         }
2059
2060         /* If symmetric RTP is enabled see if the remote side is not what we expected and change where we are sending audio */
2061         if (ast_rtp_instance_get_prop(instance, AST_RTP_PROPERTY_NAT)) {
2062                 if (ast_sockaddr_cmp(&remote_address, &addr)) {
2063                         ast_rtp_instance_set_remote_address(instance, &addr);
2064                         ast_sockaddr_copy(&remote_address, &addr);
2065                         if (rtp->rtcp) {
2066                                 ast_sockaddr_copy(&rtp->rtcp->them, &addr);
2067                                 ast_sockaddr_set_port(&rtp->rtcp->them, ast_sockaddr_port(&addr) + 1);
2068                         }
2069                         rtp->rxseqno = 0;
2070                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2071                         if (option_debug || rtpdebug)
2072                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s\n",
2073                                           ast_sockaddr_stringify(&remote_address));
2074                 }
2075         }
2076
2077         /* If we are directly bridged to another instance send the audio directly out */
2078         if (ast_rtp_instance_get_bridged(instance) && !bridge_p2p_rtp_write(instance, rtpheader, res, hdrlen)) {
2079                 return &ast_null_frame;
2080         }
2081
2082         /* If the version is not what we expected by this point then just drop the packet */
2083         if (version != 2) {
2084                 return &ast_null_frame;
2085         }
2086
2087         /* Pull out the various other fields we will need */
2088         payloadtype = (seqno & 0x7f0000) >> 16;
2089         padding = seqno & (1 << 29);
2090         mark = seqno & (1 << 23);
2091         ext = seqno & (1 << 28);
2092         cc = (seqno & 0xF000000) >> 24;
2093         seqno &= 0xffff;
2094         timestamp = ntohl(rtpheader[1]);
2095         ssrc = ntohl(rtpheader[2]);
2096
2097         AST_LIST_HEAD_INIT_NOLOCK(&frames);
2098         /* Force a marker bit and change SSRC if the SSRC changes */
2099         if (rtp->rxssrc && rtp->rxssrc != ssrc) {
2100                 struct ast_frame *f, srcupdate = {
2101                         AST_FRAME_CONTROL,
2102                         .subclass.integer = AST_CONTROL_SRCCHANGE,
2103                 };
2104
2105                 if (!mark) {
2106                         if (option_debug || rtpdebug) {
2107                                 ast_debug(1, "Forcing Marker bit, because SSRC has changed\n");
2108                         }
2109                         mark = 1;
2110                 }
2111
2112                 f = ast_frisolate(&srcupdate);
2113                 AST_LIST_INSERT_TAIL(&frames, f, frame_list);
2114         }
2115
2116         rtp->rxssrc = ssrc;
2117
2118         /* Remove any padding bytes that may be present */
2119         if (padding) {
2120                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
2121         }
2122
2123         /* Skip over any CSRC fields */
2124         if (cc) {
2125                 hdrlen += cc * 4;
2126         }
2127
2128         /* Look for any RTP extensions, currently we do not support any */
2129         if (ext) {
2130                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
2131                 hdrlen += 4;
2132                 if (option_debug) {
2133                         int profile;
2134                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
2135                         if (profile == 0x505a)
2136                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
2137                         else
2138                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
2139                 }
2140         }
2141
2142         /* Make sure after we potentially mucked with the header length that it is once again valid */
2143         if (res < hdrlen) {
2144                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d\n", res, hdrlen);
2145                 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
2146         }
2147
2148         rtp->rxcount++;
2149         if (rtp->rxcount == 1) {
2150                 rtp->seedrxseqno = seqno;
2151         }
2152
2153         /* Do not schedule RR if RTCP isn't run */
2154         if (rtp->rtcp && !ast_sockaddr_isnull(&rtp->rtcp->them) && rtp->rtcp->schedid < 1) {
2155                 /* Schedule transmission of Receiver Report */
2156                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, instance);
2157         }
2158         if ((int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
2159                 rtp->cycles += RTP_SEQ_MOD;
2160
2161         prev_seqno = rtp->lastrxseqno;
2162         rtp->lastrxseqno = seqno;
2163
2164         if (!rtp->themssrc) {
2165                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
2166         }
2167
2168         if (rtp_debug_test_addr(&addr)) {
2169                 ast_verbose("Got  RTP packet from    %s (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2170                             ast_sockaddr_stringify(&addr),
2171                             payloadtype, seqno, timestamp,res - hdrlen);
2172         }
2173
2174         payload = ast_rtp_codecs_payload_lookup(ast_rtp_instance_get_codecs(instance), payloadtype);
2175
2176         /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
2177         if (!payload.asterisk_format) {
2178                 struct ast_frame *f = NULL;
2179                 if (payload.code == AST_RTP_DTMF) {
2180                         /* process_dtmf_rfc2833 may need to return multiple frames. We do this
2181                          * by passing the pointer to the frame list to it so that the method
2182                          * can append frames to the list as needed.
2183                          */
2184                         process_dtmf_rfc2833(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark, &frames);
2185                 } else if (payload.code == AST_RTP_CISCO_DTMF) {
2186                         f = process_dtmf_cisco(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
2187                 } else if (payload.code == AST_RTP_CN) {
2188                         f = process_cn_rfc3389(instance, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp, &addr, payloadtype, mark);
2189                 } else {
2190                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n",
2191                                 payloadtype,
2192                                 ast_sockaddr_stringify(&remote_address));
2193                 }
2194
2195                 if (f) {
2196                         AST_LIST_INSERT_TAIL(&frames, f, frame_list);
2197                 }
2198                 /* Even if no frame was returned by one of the above methods,
2199                  * we may have a frame to return in our frame list
2200                  */
2201                 if (!AST_LIST_EMPTY(&frames)) {
2202                         return AST_LIST_FIRST(&frames);
2203                 }
2204                 return &ast_null_frame;
2205         }
2206
2207         rtp->lastrxformat = rtp->f.subclass.codec = payload.code;
2208         rtp->f.frametype = (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
2209
2210         rtp->rxseqno = seqno;
2211
2212         if (rtp->dtmf_timeout && rtp->dtmf_timeout < timestamp) {
2213                 rtp->dtmf_timeout = 0;
2214
2215                 if (rtp->resp) {
2216                         struct ast_frame *f;
2217                         f = create_dtmf_frame(instance, AST_FRAME_DTMF_END, 0);
2218                         f->len = ast_tvdiff_ms(ast_samp2tv(rtp->dtmf_duration, rtp_get_rate(f->subclass.codec)), ast_tv(0, 0));
2219                         rtp->resp = 0;
2220                         rtp->dtmf_timeout = rtp->dtmf_duration = 0;
2221                         AST_LIST_INSERT_TAIL(&frames, f, frame_list);
2222                         return AST_LIST_FIRST(&frames);
2223                 }
2224         }
2225
2226         rtp->lastrxts = timestamp;
2227
2228         rtp->f.src = "RTP";
2229         rtp->f.mallocd = 0;
2230         rtp->f.datalen = res - hdrlen;
2231         rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
2232         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
2233         rtp->f.seqno = seqno;
2234
2235         if (rtp->f.subclass.codec == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
2236                 unsigned char *data = rtp->f.data.ptr;
2237
2238                 memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
2239                 rtp->f.datalen +=3;
2240                 *data++ = 0xEF;
2241                 *data++ = 0xBF;
2242                 *data = 0xBD;
2243         }
2244
2245         if (rtp->f.subclass.codec == AST_FORMAT_T140RED) {
2246                 unsigned char *data = rtp->f.data.ptr;
2247                 unsigned char *header_end;
2248                 int num_generations;
2249                 int header_length;
2250                 int len;
2251                 int diff =(int)seqno - (prev_seqno+1); /* if diff = 0, no drop*/
2252                 int x;
2253
2254                 rtp->f.subclass.codec = AST_FORMAT_T140;
2255                 header_end = memchr(data, ((*data) & 0x7f), rtp->f.datalen);
2256                 if (header_end == NULL) {
2257                         return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
2258                 }
2259                 header_end++;
2260
2261                 header_length = header_end - data;
2262                 num_generations = header_length / 4;
2263                 len = header_length;
2264
2265                 if (!diff) {
2266                         for (x = 0; x < num_generations; x++)
2267                                 len += data[x * 4 + 3];
2268
2269                         if (!(rtp->f.datalen - len))
2270                                 return AST_LIST_FIRST(&frames) ? AST_LIST_FIRST(&frames) : &ast_null_frame;
2271
2272                         rtp->f.data.ptr += len;
2273                         rtp->f.datalen -= len;
2274                 } else if (diff > num_generations && diff < 10) {
2275                         len -= 3;
2276                         rtp->f.data.ptr += len;
2277                         rtp->f.datalen -= len;
2278
2279                         data = rtp->f.data.ptr;
2280                         *data++ = 0xEF;
2281                         *data++ = 0xBF;
2282                         *data = 0xBD;
2283                 } else {
2284                         for ( x = 0; x < num_generations - diff; x++)
2285                                 len += data[x * 4 + 3];
2286
2287                         rtp->f.data.ptr += len;
2288                         rtp->f.datalen -= len;
2289                 }
2290         }
2291
2292         if (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) {
2293                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
2294                 if ((rtp->f.subclass.codec == AST_FORMAT_SLINEAR) || (rtp->f.subclass.codec == AST_FORMAT_SLINEAR16)) {
2295                         ast_frame_byteswap_be(&rtp->f);
2296                 }
2297                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
2298                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
2299                 ast_set_flag(&rtp->f, AST_FRFLAG_HAS_TIMING_INFO);
2300                 rtp->f.ts = timestamp / (rtp_get_rate(rtp->f.subclass.codec) / 1000);
2301                 rtp->f.len = rtp->f.samples / ((ast_format_rate(rtp->f.subclass.codec) / 1000));
2302         } else if (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) {
2303                 /* Video -- samples is # of samples vs. 90000 */
2304                 if (!rtp->lastividtimestamp)
2305                         rtp->lastividtimestamp = timestamp;
2306                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
2307                 rtp->lastividtimestamp = timestamp;
2308                 rtp->f.delivery.tv_sec = 0;
2309                 rtp->f.delivery.tv_usec = 0;
2310                 /* Pass the RTP marker bit as bit 0 in the subclass field.
2311                  * This is ok because subclass is actually a bitmask, and
2312                  * the low bits represent audio formats, that are not
2313                  * involved here since we deal with video.
2314                  */
2315                 if (mark)
2316                         rtp->f.subclass.codec |= 0x1;
2317         } else {
2318                 /* TEXT -- samples is # of samples vs. 1000 */
2319                 if (!rtp->lastitexttimestamp)
2320                         rtp->lastitexttimestamp = timestamp;
2321                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
2322                 rtp->lastitexttimestamp = timestamp;
2323                 rtp->f.delivery.tv_sec = 0;
2324                 rtp->f.delivery.tv_usec = 0;
2325         }
2326
2327         AST_LIST_INSERT_TAIL(&frames, &rtp->f, frame_list);
2328         return AST_LIST_FIRST(&frames);
2329 }
2330
2331 static void ast_rtp_prop_set(struct ast_rtp_instance *instance, enum ast_rtp_property property, int value)
2332 {
2333         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2334
2335         if (property == AST_RTP_PROPERTY_RTCP) {
2336                 if (rtp->rtcp) {
2337                         ast_debug(1, "Ignoring duplicate RTCP property on RTP instance '%p'\n", instance);
2338                         return;
2339                 }
2340                 if (!(rtp->rtcp = ast_calloc(1, sizeof(*rtp->rtcp)))) {
2341                         return;
2342                 }
2343
2344                 /* Grab the IP address and port we are going to use */
2345                 ast_rtp_instance_get_local_address(instance, &rtp->rtcp->us);
2346                 ast_sockaddr_set_port(&rtp->rtcp->us,
2347                                       ast_sockaddr_port(&rtp->rtcp->us) + 1);
2348
2349                 if ((rtp->rtcp->s =
2350                      create_new_socket("RTCP",
2351                                        ast_sockaddr_is_ipv4(&rtp->rtcp->us) ?
2352                                        AF_INET :
2353                                        ast_sockaddr_is_ipv6(&rtp->rtcp->us) ?
2354                                        AF_INET6 : -1)) < 0) {
2355                         ast_debug(1, "Failed to create a new socket for RTCP on instance '%p'\n", instance);
2356                         ast_free(rtp->rtcp);
2357                         rtp->rtcp = NULL;
2358                         return;
2359                 }
2360
2361                 /* 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 */
2362                 if (ast_bind(rtp->rtcp->s, &rtp->rtcp->us)) {
2363                         ast_debug(1, "Failed to setup RTCP on RTP instance '%p'\n", instance);
2364                         close(rtp->rtcp->s);
2365                         ast_free(rtp->rtcp);
2366                         rtp->rtcp = NULL;
2367                         return;
2368                 }
2369
2370                 ast_debug(1, "Setup RTCP on RTP instance '%p'\n", instance);
2371                 rtp->rtcp->schedid = -1;
2372
2373                 return;
2374         }
2375
2376         return;
2377 }
2378
2379 static int ast_rtp_fd(struct ast_rtp_instance *instance, int rtcp)
2380 {
2381         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2382
2383         return rtcp ? (rtp->rtcp ? rtp->rtcp->s : -1) : rtp->s;
2384 }
2385
2386 static void ast_rtp_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
2387 {
2388         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2389
2390         if (rtp->rtcp) {
2391                 ast_debug(1, "Setting RTCP address on RTP instance '%p'\n", instance);
2392                 ast_sockaddr_copy(&rtp->rtcp->them, addr);
2393                 if (!ast_sockaddr_isnull(addr)) {
2394                         ast_sockaddr_set_port(&rtp->rtcp->them,
2395                                               ast_sockaddr_port(addr) + 1);
2396                 }
2397         }
2398
2399         rtp->rxseqno = 0;
2400
2401         if (strictrtp) {
2402                 rtp->strict_rtp_state = STRICT_RTP_LEARN;
2403         }
2404
2405         return;
2406 }
2407
2408 static void ast_rtp_alt_remote_address_set(struct ast_rtp_instance *instance, struct ast_sockaddr *addr)
2409 {
2410         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2411
2412         /* No need to futz with rtp->rtcp here because ast_rtcp_read is already able to adjust if receiving
2413          * RTCP from an "unexpected" source
2414          */
2415         ast_sockaddr_copy(&rtp->alt_rtp_address, addr);
2416
2417         return;
2418 }
2419
2420 /*! \brief Write t140 redundacy frame
2421  * \param data primary data to be buffered
2422  */
2423 static int red_write(const void *data)
2424 {
2425         struct ast_rtp_instance *instance = (struct ast_rtp_instance*) data;
2426         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2427
2428         ast_rtp_write(instance, &rtp->red->t140);
2429
2430         return 1;
2431 }
2432
2433 static int rtp_red_init(struct ast_rtp_instance *instance, int buffer_time, int *payloads, int generations)
2434 {
2435         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2436         int x;
2437
2438         if (!(rtp->red = ast_calloc(1, sizeof(*rtp->red)))) {
2439                 return -1;
2440         }
2441
2442         rtp->red->t140.frametype = AST_FRAME_TEXT;
2443         rtp->red->t140.subclass.codec = AST_FORMAT_T140RED;
2444         rtp->red->t140.data.ptr = &rtp->red->buf_data;
2445
2446         rtp->red->t140.ts = 0;
2447         rtp->red->t140red = rtp->red->t140;
2448         rtp->red->t140red.data.ptr = &rtp->red->t140red_data;
2449         rtp->red->t140red.datalen = 0;
2450         rtp->red->ti = buffer_time;
2451         rtp->red->num_gen = generations;
2452         rtp->red->hdrlen = generations * 4 + 1;
2453         rtp->red->prev_ts = 0;
2454
2455         for (x = 0; x < generations; x++) {
2456                 rtp->red->pt[x] = payloads[x];
2457                 rtp->red->pt[x] |= 1 << 7; /* mark redundant generations pt */
2458                 rtp->red->t140red_data[x*4] = rtp->red->pt[x];
2459         }
2460         rtp->red->t140red_data[x*4] = rtp->red->pt[x] = payloads[x]; /* primary pt */
2461         rtp->red->schedid = ast_sched_add(rtp->sched, generations, red_write, instance);
2462
2463         rtp->red->t140.datalen = 0;
2464
2465         return 0;
2466 }
2467
2468 static int rtp_red_buffer(struct ast_rtp_instance *instance, struct ast_frame *frame)
2469 {
2470         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2471
2472         if (frame->datalen > -1) {
2473                 struct rtp_red *red = rtp->red;
2474                 memcpy(&red->buf_data[red->t140.datalen], frame->data.ptr, frame->datalen);
2475                 red->t140.datalen += frame->datalen;
2476                 red->t140.ts = frame->ts;
2477         }
2478
2479         return 0;
2480 }
2481
2482 static int ast_rtp_local_bridge(struct ast_rtp_instance *instance0, struct ast_rtp_instance *instance1)
2483 {
2484         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance0);
2485
2486         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2487
2488         return 0;
2489 }
2490
2491 static int ast_rtp_get_stat(struct ast_rtp_instance *instance, struct ast_rtp_instance_stats *stats, enum ast_rtp_instance_stat stat)
2492 {
2493         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2494
2495         if (!rtp->rtcp) {
2496                 return -1;
2497         }
2498
2499         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXCOUNT, -1, stats->txcount, rtp->txcount);
2500         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RXCOUNT, -1, stats->rxcount, rtp->rxcount);
2501
2502         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->txploss, rtp->rtcp->reported_lost);
2503         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);
2504         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_maxrxploss, rtp->rtcp->reported_maxlost);
2505         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_minrxploss, rtp->rtcp->reported_minlost);
2506         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_normdevrxploss, rtp->rtcp->reported_normdev_lost);
2507         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->remote_stdevrxploss, rtp->rtcp->reported_stdev_lost);
2508         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_maxrxploss, rtp->rtcp->maxrxlost);
2509         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_minrxploss, rtp->rtcp->minrxlost);
2510         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_normdevrxploss, rtp->rtcp->normdev_rxlost);
2511         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVRXPLOSS, AST_RTP_INSTANCE_STAT_COMBINED_LOSS, stats->local_stdevrxploss, rtp->rtcp->stdev_rxlost);
2512         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_LOSS);
2513
2514         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_TXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->txjitter, rtp->rxjitter);
2515         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);
2516         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_maxjitter, rtp->rtcp->reported_maxjitter);
2517         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_minjitter, rtp->rtcp->reported_minjitter);
2518         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_normdevjitter, rtp->rtcp->reported_normdev_jitter);
2519         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->remote_stdevjitter, rtp->rtcp->reported_stdev_jitter);
2520         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MAXJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_maxjitter, rtp->rtcp->maxrxjitter);
2521         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_MINJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_minjitter, rtp->rtcp->minrxjitter);
2522         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_NORMDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_normdevjitter, rtp->rtcp->normdev_rxjitter);
2523         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_STDEVJITTER, AST_RTP_INSTANCE_STAT_COMBINED_JITTER, stats->local_stdevjitter, rtp->rtcp->stdev_rxjitter);
2524         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_JITTER);
2525
2526         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->rtt, rtp->rtcp->rtt);
2527         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MAX_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->maxrtt, rtp->rtcp->maxrtt);
2528         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_MIN_RTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->minrtt, rtp->rtcp->minrtt);
2529         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_NORMDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->normdevrtt, rtp->rtcp->normdevrtt);
2530         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_STDEVRTT, AST_RTP_INSTANCE_STAT_COMBINED_RTT, stats->stdevrtt, rtp->rtcp->stdevrtt);
2531         AST_RTP_STAT_TERMINATOR(AST_RTP_INSTANCE_STAT_COMBINED_RTT);
2532
2533         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_LOCAL_SSRC, -1, stats->local_ssrc, rtp->ssrc);
2534         AST_RTP_STAT_SET(AST_RTP_INSTANCE_STAT_REMOTE_SSRC, -1, stats->remote_ssrc, rtp->themssrc);
2535
2536         return 0;
2537 }
2538
2539 static int ast_rtp_dtmf_compatible(struct ast_channel *chan0, struct ast_rtp_instance *instance0, struct ast_channel *chan1, struct ast_rtp_instance *instance1)
2540 {
2541         /* If both sides are not using the same method of DTMF transmission
2542          * (ie: one is RFC2833, other is INFO... then we can not do direct media.
2543          * --------------------------------------------------
2544          * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
2545          * |-----------|------------|-----------------------|
2546          * | Inband    | False      | True                  |
2547          * | RFC2833   | True       | True                  |
2548          * | SIP INFO  | False      | False                 |
2549          * --------------------------------------------------
2550          */
2551         return (((ast_rtp_instance_get_prop(instance0, AST_RTP_PROPERTY_DTMF) != ast_rtp_instance_get_prop(instance1, AST_RTP_PROPERTY_DTMF)) ||
2552                  (!chan0->tech->send_digit_begin != !chan1->tech->send_digit_begin)) ? 0 : 1);
2553 }
2554
2555 static void ast_rtp_stun_request(struct ast_rtp_instance *instance, struct ast_sockaddr *suggestion, const char *username)
2556 {
2557         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2558         struct sockaddr_in suggestion_tmp;
2559
2560         ast_sockaddr_to_sin(suggestion, &suggestion_tmp);
2561         ast_stun_request(rtp->s, &suggestion_tmp, username, NULL);
2562         ast_sockaddr_from_sin(suggestion, &suggestion_tmp);
2563 }
2564
2565 static void ast_rtp_stop(struct ast_rtp_instance *instance)
2566 {
2567         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2568         struct ast_sockaddr addr = { {0,} };
2569
2570         if (rtp->rtcp) {
2571                 AST_SCHED_DEL(rtp->sched, rtp->rtcp->schedid);
2572         }
2573         if (rtp->red) {
2574                 AST_SCHED_DEL(rtp->sched, rtp->red->schedid);
2575                 free(rtp->red);
2576                 rtp->red = NULL;
2577         }
2578
2579         ast_rtp_instance_set_remote_address(instance, &addr);
2580         if (rtp->rtcp) {
2581                 ast_sockaddr_setnull(&rtp->rtcp->them);
2582         }
2583
2584         ast_set_flag(rtp, FLAG_NEED_MARKER_BIT);
2585 }
2586
2587 static int ast_rtp_qos_set(struct ast_rtp_instance *instance, int tos, int cos, const char *desc)
2588 {
2589         struct ast_rtp *rtp = ast_rtp_instance_get_data(instance);
2590
2591         return ast_set_qos(rtp->s, tos, cos, desc);
2592 }
2593
2594 static char *rtp_do_debug_ip(struct ast_cli_args *a)
2595 {
2596         char *arg = ast_strdupa(a->argv[4]);
2597
2598         if (!ast_sockaddr_parse(&rtpdebugaddr, arg, 0)) {
2599                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2600                 return CLI_FAILURE;
2601         }
2602         ast_cli(a->fd, "RTP Debugging Enabled for address: %s\n",
2603                 ast_sockaddr_stringify(&rtpdebugaddr));
2604         rtpdebug = 1;
2605         return CLI_SUCCESS;
2606 }
2607
2608 static char *rtcp_do_debug_ip(struct ast_cli_args *a)
2609 {
2610         char *arg = ast_strdupa(a->argv[4]);
2611
2612         if (!ast_sockaddr_parse(&rtcpdebugaddr, arg, 0)) {
2613                 ast_cli(a->fd, "Lookup failed for '%s'\n", arg);
2614                 return CLI_FAILURE;
2615         }
2616         ast_cli(a->fd, "RTCP Debugging Enabled for address: %s\n",
2617                 ast_sockaddr_stringify(&rtcpdebugaddr));
2618         rtcpdebug = 1;
2619         return CLI_SUCCESS;
2620 }
2621
2622 static char *handle_cli_rtp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2623 {
2624         switch (cmd) {
2625         case CLI_INIT:
2626                 e->command = "rtp set debug {on|off|ip}";
2627                 e->usage =
2628                         "Usage: rtp set debug {on|off|ip host[:port]}\n"
2629                         "       Enable/Disable dumping of all RTP packets. If 'ip' is\n"
2630                         "       specified, limit the dumped packets to those to and from\n"
2631                         "       the specified 'host' with optional port.\n";
2632                 return NULL;
2633         case CLI_GENERATE:
2634                 return NULL;
2635         }
2636
2637         if (a->argc == e->args) { /* set on or off */
2638                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2639                         rtpdebug = 1;
2640                         memset(&rtpdebugaddr, 0, sizeof(rtpdebugaddr));
2641                         ast_cli(a->fd, "RTP Debugging Enabled\n");
2642                         return CLI_SUCCESS;
2643                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2644                         rtpdebug = 0;
2645                         ast_cli(a->fd, "RTP Debugging Disabled\n");
2646                         return CLI_SUCCESS;
2647                 }
2648         } else if (a->argc == e->args +1) { /* ip */
2649                 return rtp_do_debug_ip(a);
2650         }
2651
2652         return CLI_SHOWUSAGE;   /* default, failure */
2653 }
2654
2655 static char *handle_cli_rtcp_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2656 {
2657         switch (cmd) {
2658         case CLI_INIT:
2659                 e->command = "rtcp set debug {on|off|ip}";
2660                 e->usage =
2661                         "Usage: rtcp set debug {on|off|ip host[:port]}\n"
2662                         "       Enable/Disable dumping of all RTCP packets. If 'ip' is\n"
2663                         "       specified, limit the dumped packets to those to and from\n"
2664                         "       the specified 'host' with optional port.\n";
2665                 return NULL;
2666         case CLI_GENERATE:
2667                 return NULL;
2668         }
2669
2670         if (a->argc == e->args) { /* set on or off */
2671                 if (!strncasecmp(a->argv[e->args-1], "on", 2)) {
2672                         rtcpdebug = 1;
2673                         memset(&rtcpdebugaddr, 0, sizeof(rtcpdebugaddr));
2674                         ast_cli(a->fd, "RTCP Debugging Enabled\n");
2675                         return CLI_SUCCESS;
2676                 } else if (!strncasecmp(a->argv[e->args-1], "off", 3)) {
2677                         rtcpdebug = 0;
2678                         ast_cli(a->fd, "RTCP Debugging Disabled\n");
2679                         return CLI_SUCCESS;
2680                 }
2681         } else if (a->argc == e->args +1) { /* ip */
2682                 return rtcp_do_debug_ip(a);
2683         }
2684
2685         return CLI_SHOWUSAGE;   /* default, failure */
2686 }
2687
2688 static char *handle_cli_rtcp_set_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2689 {
2690         switch (cmd) {
2691         case CLI_INIT:
2692                 e->command = "rtcp set stats {on|off}";
2693                 e->usage =
2694                         "Usage: rtcp set stats {on|off}\n"
2695                         "       Enable/Disable dumping of RTCP stats.\n";
2696                 return NULL;
2697         case CLI_GENERATE:
2698                 return NULL;
2699         }
2700
2701         if (a->argc != e->args)
2702                 return CLI_SHOWUSAGE;
2703
2704         if (!strncasecmp(a->argv[e->args-1], "on", 2))
2705                 rtcpstats = 1;
2706         else if (!strncasecmp(a->argv[e->args-1], "off", 3))
2707                 rtcpstats = 0;
2708         else
2709                 return CLI_SHOWUSAGE;
2710
2711         ast_cli(a->fd, "RTCP Stats %s\n", rtcpstats ? "Enabled" : "Disabled");
2712         return CLI_SUCCESS;
2713 }
2714
2715 static struct ast_cli_entry cli_rtp[] = {
2716         AST_CLI_DEFINE(handle_cli_rtp_set_debug,  "Enable/Disable RTP debugging"),
2717         AST_CLI_DEFINE(handle_cli_rtcp_set_debug, "Enable/Disable RTCP debugging"),
2718         AST_CLI_DEFINE(handle_cli_rtcp_set_stats, "Enable/Disable RTCP stats"),
2719 };
2720
2721 static int rtp_reload(int reload)
2722 {
2723         struct ast_config *cfg;
2724         const char *s;
2725         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
2726
2727         cfg = ast_config_load2("rtp.conf", "rtp", config_flags);
2728         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
2729                 return 0;
2730         }
2731
2732         rtpstart = DEFAULT_RTP_START;
2733         rtpend = DEFAULT_RTP_END;
2734         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2735         strictrtp = STRICT_RTP_OPEN;
2736         if (cfg) {
2737                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
2738                         rtpstart = atoi(s);
2739                         if (rtpstart < MINIMUM_RTP_PORT)
2740                                 rtpstart = MINIMUM_RTP_PORT;
2741                         if (rtpstart > MAXIMUM_RTP_PORT)
2742                                 rtpstart = MAXIMUM_RTP_PORT;
2743                 }
2744                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
2745                         rtpend = atoi(s);
2746                         if (rtpend < MINIMUM_RTP_PORT)
2747                                 rtpend = MINIMUM_RTP_PORT;
2748                         if (rtpend > MAXIMUM_RTP_PORT)
2749                                 rtpend = MAXIMUM_RTP_PORT;
2750                 }
2751                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
2752                         rtcpinterval = atoi(s);
2753                         if (rtcpinterval == 0)
2754                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
2755                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
2756                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
2757                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
2758                                 rtcpinterval = RTCP_MAX_INTERVALMS;
2759                 }
2760                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
2761 #ifdef SO_NO_CHECK
2762                         nochecksums = ast_false(s) ? 1 : 0;
2763 #else
2764                         if (ast_false(s))
2765                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
2766 #endif
2767                 }
2768                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
2769                         dtmftimeout = atoi(s);
2770                         if ((dtmftimeout < 0) || (dtmftimeout > 64000)) {
2771                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
2772                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
2773                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
2774                         };
2775                 }
2776                 if ((s = ast_variable_retrieve(cfg, "general", "strictrtp"))) {
2777                         strictrtp = ast_true(s);
2778                 }
2779                 ast_config_destroy(cfg);
2780         }
2781         if (rtpstart >= rtpend) {
2782                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
2783                 rtpstart = DEFAULT_RTP_START;
2784                 rtpend = DEFAULT_RTP_END;
2785         }
2786         ast_verb(2, "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
2787         return 0;
2788 }
2789
2790 static int reload_module(void)
2791 {
2792         rtp_reload(1);
2793         return 0;
2794 }
2795
2796 static int load_module(void)
2797 {
2798         if (ast_rtp_engine_register(&asterisk_rtp_engine)) {
2799                 return AST_MODULE_LOAD_DECLINE;
2800         }
2801
2802         if (ast_cli_register_multiple(cli_rtp, ARRAY_LEN(cli_rtp))) {
2803                 ast_rtp_engine_unregister(&asterisk_rtp_engine);
2804                 return AST_MODULE_LOAD_DECLINE;
2805         }
2806
2807         rtp_reload(0);
2808
2809         return AST_MODULE_LOAD_SUCCESS;
2810 }
2811
2812 static int unload_module(void)
2813 {
2814         ast_rtp_engine_unregister(&asterisk_rtp_engine);
2815         ast_cli_unregister_multiple(cli_rtp, ARRAY_LEN(cli_rtp));
2816
2817         return 0;
2818 }
2819
2820 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Asterisk RTP Stack",
2821                 .load = load_module,
2822                 .unload = unload_module,
2823                 .reload = reload_module,
2824                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
2825                 );