silly people that don't want to install/run autoconf :-)
[asterisk/asterisk.git] / rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  * 
26  * \note RTP is defined in RFC 3550.
27  */
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/time.h>
33 #include <signal.h>
34 #include <errno.h>
35 #include <unistd.h>
36 #include <netinet/in.h>
37 #include <sys/time.h>
38 #include <sys/socket.h>
39 #include <arpa/inet.h>
40 #include <fcntl.h>
41
42 #include "asterisk.h"
43
44 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/cli.h"
57 #include "asterisk/unaligned.h"
58 #include "asterisk/utils.h"
59
60 #define MAX_TIMESTAMP_SKEW      640
61
62 #define RTP_MTU         1200
63
64 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
65
66 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
67
68 static int rtpstart = 0;                /*!< First port for RTP sessions (set in rtp.conf) */
69 static int rtpend = 0;                  /*!< Last port for RTP sessions (set in rtp.conf) */
70 static int rtpdebug = 0;                /*!< Are we debugging? */
71 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
72 #ifdef SO_NO_CHECK
73 static int nochecksums = 0;
74 #endif
75
76 /*! \brief The value of each payload format mapping: */
77 struct rtpPayloadType {
78         int isAstFormat;        /*!< whether the following code is an AST_FORMAT */
79         int code;
80 };
81
82 #define MAX_RTP_PT                      256
83
84 #define FLAG_3389_WARNING               (1 << 0)
85 #define FLAG_NAT_ACTIVE                 (3 << 1)
86 #define FLAG_NAT_INACTIVE               (0 << 1)
87 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
88
89 /*! \brief RTP session description */
90 struct ast_rtp {
91         int s;
92         char resp;
93         struct ast_frame f;
94         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
95         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
96         unsigned int lastts;
97         unsigned int lastdigitts;
98         unsigned int lastrxts;
99         unsigned int lastividtimestamp;
100         unsigned int lastovidtimestamp;
101         unsigned int lasteventseqn;
102         unsigned int lasteventendseqn;
103         int lasttxformat;
104         int lastrxformat;
105         int dtmfcount;
106         unsigned int dtmfduration;
107         int nat;
108         unsigned int flags;
109         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
110         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
111         struct timeval rxcore;
112         struct timeval txcore;
113         struct timeval dtmfmute;
114         struct ast_smoother *smoother;
115         int *ioid;
116         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
117         unsigned short rxseqno;
118         struct sched_context *sched;
119         struct io_context *io;
120         void *data;
121         ast_rtp_callback callback;
122         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
123         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
124         int rtp_lookup_code_cache_code;
125         int rtp_lookup_code_cache_result;
126         struct ast_rtcp *rtcp;
127 };
128
129 /*!
130  * \brief Structure defining an RTCP session.
131  * 
132  * The concept "RTCP session" is not defined in RFC 3550, but since 
133  * this structure is analogous to ast_rtp, which tracks a RTP session, 
134  * it is logical to think of this as a RTCP session.
135  *
136  * RTCP packet is defined on page 9 of RFC 3550.
137  * 
138  */
139 struct ast_rtcp {
140         int s;                          /*!< Socket */
141         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
142         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
143 };
144
145 /*! \brief List of current sessions */
146 static AST_LIST_HEAD_STATIC(protos, ast_rtp_protocol);
147
148 int ast_rtp_fd(struct ast_rtp *rtp)
149 {
150         return rtp->s;
151 }
152
153 int ast_rtcp_fd(struct ast_rtp *rtp)
154 {
155         if (rtp->rtcp)
156                 return rtp->rtcp->s;
157         return -1;
158 }
159
160 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
161 {
162         rtp->data = data;
163 }
164
165 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
166 {
167         rtp->callback = callback;
168 }
169
170 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
171 {
172         rtp->nat = nat;
173 }
174
175 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
176 {
177         char iabuf[INET_ADDRSTRLEN];
178
179         if (ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
180                 if (option_debug)
181                         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
182                 rtp->resp = 0;
183                 rtp->dtmfduration = 0;
184                 return &ast_null_frame;
185         }
186         if (option_debug)
187                 ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
188         if (rtp->resp == 'X') {
189                 rtp->f.frametype = AST_FRAME_CONTROL;
190                 rtp->f.subclass = AST_CONTROL_FLASH;
191         } else {
192                 rtp->f.frametype = AST_FRAME_DTMF;
193                 rtp->f.subclass = rtp->resp;
194         }
195         rtp->f.datalen = 0;
196         rtp->f.samples = 0;
197         rtp->f.mallocd = 0;
198         rtp->f.src = "RTP";
199         rtp->resp = 0;
200         rtp->dtmfduration = 0;
201         return &rtp->f;
202         
203 }
204
205 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
206 {
207         if (rtpdebug == 0)
208                 return 0;
209         if (rtpdebugaddr.sin_addr.s_addr) {
210                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
211                         && (rtpdebugaddr.sin_port != addr->sin_port))
212                         || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
213                 return 0;
214         }
215         return 1;
216 }
217
218 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
219 {
220         unsigned int event;
221         char resp = 0;
222         struct ast_frame *f = NULL;
223         event = ntohl(*((unsigned int *)(data)));
224         event &= 0x001F;
225         if (option_debug > 2 || rtpdebug)
226                 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %08x (len = %d)\n", event, len);
227         if (event < 10) {
228                 resp = '0' + event;
229         } else if (event < 11) {
230                 resp = '*';
231         } else if (event < 12) {
232                 resp = '#';
233         } else if (event < 16) {
234                 resp = 'A' + (event - 12);
235         } else if (event < 17) {
236                 resp = 'X';
237         }
238         if (rtp->resp && (rtp->resp != resp)) {
239                 f = send_dtmf(rtp);
240         }
241         rtp->resp = resp;
242         rtp->dtmfcount = dtmftimeout;
243         return f;
244 }
245
246 /*! 
247  * \brief Process RTP DTMF and events according to RFC 2833.
248  * 
249  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
250  * 
251  * \param rtp
252  * \param data
253  * \param len
254  * \param seqno
255  * \returns
256  */
257 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
258 {
259         unsigned int event;
260         unsigned int event_end;
261         unsigned int duration;
262         char resp = 0;
263         struct ast_frame *f = NULL;
264
265         event = ntohl(*((unsigned int *)(data)));
266         event >>= 24;
267         event_end = ntohl(*((unsigned int *)(data)));
268         event_end <<= 8;
269         event_end >>= 24;
270         duration = ntohl(*((unsigned int *)(data)));
271         duration &= 0xFFFF;
272         if (rtpdebug || option_debug > 2)
273                 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
274         if (event < 10) {
275                 resp = '0' + event;
276         } else if (event < 11) {
277                 resp = '*';
278         } else if (event < 12) {
279                 resp = '#';
280         } else if (event < 16) {
281                 resp = 'A' + (event - 12);
282         } else if (event < 17) {        /* Event 16: Hook flash */
283                 resp = 'X';     
284         }
285         if (rtp->resp && (rtp->resp != resp)) {
286                 f = send_dtmf(rtp);
287         } else if(event_end & 0x80) {
288                 if (rtp->resp) {
289                         if(rtp->lasteventendseqn != seqno) {
290                                 f = send_dtmf(rtp);
291                                 rtp->lasteventendseqn = seqno;
292                         }
293                         rtp->resp = 0;
294                 }
295                 resp = 0;
296                 duration = 0;
297         } else if (rtp->resp && rtp->dtmfduration && (duration < rtp->dtmfduration)) {
298                 f = send_dtmf(rtp);
299         }
300         if (!(event_end & 0x80))
301                 rtp->resp = resp;
302         rtp->dtmfcount = dtmftimeout;
303         rtp->dtmfduration = duration;
304         return f;
305 }
306
307 /*!
308  * \brief Process Comfort Noise RTP.
309  * 
310  * This is incomplete at the moment.
311  * 
312 */
313 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
314 {
315         struct ast_frame *f = NULL;
316         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
317            totally help us out becuase we don't have an engine to keep it going and we are not
318            guaranteed to have it every 20ms or anything */
319         if (rtpdebug)
320                 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
321
322         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
323                 char iabuf[INET_ADDRSTRLEN];
324
325                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
326                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
327                 ast_set_flag(rtp, FLAG_3389_WARNING);
328         }
329
330         /* Must have at least one byte */
331         if (!len)
332                 return NULL;
333         if (len < 24) {
334                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
335                 rtp->f.datalen = len - 1;
336                 rtp->f.offset = AST_FRIENDLY_OFFSET;
337                 memcpy(rtp->f.data, data + 1, len - 1);
338         } else {
339                 rtp->f.data = NULL;
340                 rtp->f.offset = 0;
341                 rtp->f.datalen = 0;
342         }
343         rtp->f.frametype = AST_FRAME_CNG;
344         rtp->f.subclass = data[0] & 0x7f;
345         rtp->f.datalen = len - 1;
346         rtp->f.samples = 0;
347         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
348         f = &rtp->f;
349         return f;
350 }
351
352 static int rtpread(int *id, int fd, short events, void *cbdata)
353 {
354         struct ast_rtp *rtp = cbdata;
355         struct ast_frame *f;
356         f = ast_rtp_read(rtp);
357         if (f) {
358                 if (rtp->callback)
359                         rtp->callback(rtp, f, rtp->data);
360         }
361         return 1;
362 }
363
364 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
365 {
366         socklen_t len;
367         int hdrlen = 8;
368         int res;
369         struct sockaddr_in sin;
370         unsigned int rtcpdata[1024];
371         char iabuf[INET_ADDRSTRLEN];
372         
373         if (!rtp || !rtp->rtcp)
374                 return &ast_null_frame;
375
376         len = sizeof(sin);
377         
378         res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
379                                         0, (struct sockaddr *)&sin, &len);
380         
381         if (res < 0) {
382                 if (errno != EAGAIN)
383                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
384                 if (errno == EBADF)
385                         CRASH;
386                 return &ast_null_frame;
387         }
388
389         if (res < hdrlen) {
390                 ast_log(LOG_WARNING, "RTP Read too short\n");
391                 return &ast_null_frame;
392         }
393
394         if (rtp->nat) {
395                 /* Send to whoever sent to us */
396                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
397                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
398                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
399                         if (option_debug || rtpdebug)
400                                 ast_log(LOG_DEBUG, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
401                 }
402         }
403         if (option_debug)
404                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
405         return &ast_null_frame;
406 }
407
408 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
409 {
410         struct timeval ts = ast_samp2tv( timestamp, 8000);
411         if (ast_tvzero(rtp->rxcore) || mark) {
412                 rtp->rxcore = ast_tvsub(ast_tvnow(), ts);
413                 /* Round to 20ms for nice, pretty timestamps */
414                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
415         }
416         *tv = ast_tvadd(rtp->rxcore, ts);
417 }
418
419 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
420 {
421         int res;
422         struct sockaddr_in sin;
423         socklen_t len;
424         unsigned int seqno;
425         int version;
426         int payloadtype;
427         int hdrlen = 12;
428         int padding;
429         int mark;
430         int ext;
431         int x;
432         char iabuf[INET_ADDRSTRLEN];
433         unsigned int timestamp;
434         unsigned int *rtpheader;
435         struct rtpPayloadType rtpPT;
436         
437         len = sizeof(sin);
438         
439         /* Cache where the header will go */
440         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
441                                         0, (struct sockaddr *)&sin, &len);
442
443
444         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
445         if (res < 0) {
446                 if (errno != EAGAIN)
447                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
448                 if (errno == EBADF)
449                         CRASH;
450                 return &ast_null_frame;
451         }
452         if (res < hdrlen) {
453                 ast_log(LOG_WARNING, "RTP Read too short\n");
454                 return &ast_null_frame;
455         }
456
457         /* Ignore if the other side hasn't been given an address
458            yet.  */
459         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
460                 return &ast_null_frame;
461
462         if (rtp->nat) {
463                 /* Send to whoever sent to us */
464                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
465                     (rtp->them.sin_port != sin.sin_port)) {
466                         rtp->them = sin;
467                         rtp->rxseqno = 0;
468                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
469                         if (option_debug || rtpdebug)
470                                 ast_log(LOG_DEBUG, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
471                 }
472         }
473
474         /* Get fields */
475         seqno = ntohl(rtpheader[0]);
476
477         /* Check RTP version */
478         version = (seqno & 0xC0000000) >> 30;
479         if (version != 2)
480                 return &ast_null_frame;
481         
482         payloadtype = (seqno & 0x7f0000) >> 16;
483         padding = seqno & (1 << 29);
484         mark = seqno & (1 << 23);
485         ext = seqno & (1 << 28);
486         seqno &= 0xffff;
487         timestamp = ntohl(rtpheader[1]);
488         
489         if (padding) {
490                 /* Remove padding bytes */
491                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
492         }
493         
494         if (ext) {
495                 /* RTP Extension present */
496                 hdrlen += 4;
497                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
498         }
499
500         if (res < hdrlen) {
501                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
502                 return &ast_null_frame;
503         }
504
505         if(rtp_debug_test_addr(&sin))
506                 ast_verbose("Got RTP packet from %s:%d (type %d, seq %d, ts %d, len %d)\n"
507                         , ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
508
509         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
510         if (!rtpPT.isAstFormat) {
511                 struct ast_frame *f = NULL;
512
513                 /* This is special in-band data that's not one of our codecs */
514                 if (rtpPT.code == AST_RTP_DTMF) {
515                         /* It's special -- rfc2833 process it */
516                         if(rtp_debug_test_addr(&sin)) {
517                                 unsigned char *data;
518                                 unsigned int event;
519                                 unsigned int event_end;
520                                 unsigned int duration;
521                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
522                                 event = ntohl(*((unsigned int *)(data)));
523                                 event >>= 24;
524                                 event_end = ntohl(*((unsigned int *)(data)));
525                                 event_end <<= 8;
526                                 event_end >>= 24;
527                                 duration = ntohl(*((unsigned int *)(data)));
528                                 duration &= 0xFFFF;
529                                 ast_verbose("Got rfc2833 RTP packet from %s:%d (type %d, seq %d, ts %d, len %d, mark %d, event %08x, end %d, duration %d) \n", ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
530                         }
531                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
532                                 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
533                                 rtp->lasteventseqn = seqno;
534                         }
535                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
536                         /* It's really special -- process it the Cisco way */
537                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
538                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
539                                 rtp->lasteventseqn = seqno;
540                         }
541                 } else if (rtpPT.code == AST_RTP_CN) {
542                         /* Comfort Noise */
543                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
544                 } else {
545                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
546                 }
547                 return f ? f : &ast_null_frame;
548         }
549         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
550         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
551
552         if (!rtp->lastrxts)
553                 rtp->lastrxts = timestamp;
554
555         if (rtp->rxseqno) {
556                 for (x=rtp->rxseqno + 1; x < seqno; x++) {
557                         /* Queue empty frames */
558                         rtp->f.mallocd = 0;
559                         rtp->f.datalen = 0;
560                         rtp->f.data = NULL;
561                         rtp->f.offset = 0;
562                         rtp->f.samples = 0;
563                         rtp->f.src = "RTPMissedFrame";
564                 }
565         }
566         rtp->rxseqno = seqno;
567
568         if (rtp->dtmfcount) {
569 #if 0
570                 printf("dtmfcount was %d\n", rtp->dtmfcount);
571 #endif          
572                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
573                 if (rtp->dtmfcount < 0)
574                         rtp->dtmfcount = 0;
575 #if 0
576                 if (dtmftimeout != rtp->dtmfcount)
577                         printf("dtmfcount is %d\n", rtp->dtmfcount);
578 #endif
579         }
580         rtp->lastrxts = timestamp;
581
582         /* Send any pending DTMF */
583         if (rtp->resp && !rtp->dtmfcount) {
584                 if (option_debug)
585                         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
586                 return send_dtmf(rtp);
587         }
588         rtp->f.mallocd = 0;
589         rtp->f.datalen = res - hdrlen;
590         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
591         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
592         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
593                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
594                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
595                         ast_frame_byteswap_be(&rtp->f);
596                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
597         } else {
598                 /* Video -- samples is # of samples vs. 90000 */
599                 if (!rtp->lastividtimestamp)
600                         rtp->lastividtimestamp = timestamp;
601                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
602                 rtp->lastividtimestamp = timestamp;
603                 rtp->f.delivery.tv_sec = 0;
604                 rtp->f.delivery.tv_usec = 0;
605                 if (mark)
606                         rtp->f.subclass |= 0x1;
607                 
608         }
609         rtp->f.src = "RTP";
610         return &rtp->f;
611 }
612
613 /* The following array defines the MIME Media type (and subtype) for each
614    of our codecs, or RTP-specific data type. */
615 static struct {
616         struct rtpPayloadType payloadType;
617         char* type;
618         char* subtype;
619 } mimeTypes[] = {
620         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
621         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
622         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
623         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
624         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
625         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
626         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
627         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
628         {{1, AST_FORMAT_G729A}, "audio", "G729"},
629         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
630         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
631         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
632         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
633         {{0, AST_RTP_CN}, "audio", "CN"},
634         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
635         {{1, AST_FORMAT_PNG}, "video", "PNG"},
636         {{1, AST_FORMAT_H261}, "video", "H261"},
637         {{1, AST_FORMAT_H263}, "video", "H263"},
638         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
639         {{1, AST_FORMAT_H264}, "video", "H264"},
640 };
641
642 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
643    also, our own choices for dynamic payload types.  This is our master
644    table for transmission */
645 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
646         [0] = {1, AST_FORMAT_ULAW},
647 #ifdef USE_DEPRECATED_G726
648         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
649 #endif
650         [3] = {1, AST_FORMAT_GSM},
651         [4] = {1, AST_FORMAT_G723_1},
652         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
653         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
654         [7] = {1, AST_FORMAT_LPC10},
655         [8] = {1, AST_FORMAT_ALAW},
656         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
657         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
658         [13] = {0, AST_RTP_CN},
659         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
660         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
661         [18] = {1, AST_FORMAT_G729A},
662         [19] = {0, AST_RTP_CN},         /* Also used for CN */
663         [26] = {1, AST_FORMAT_JPEG},
664         [31] = {1, AST_FORMAT_H261},
665         [34] = {1, AST_FORMAT_H263},
666         [103] = {1, AST_FORMAT_H263_PLUS},
667         [97] = {1, AST_FORMAT_ILBC},
668         [99] = {1, AST_FORMAT_H264},
669         [101] = {0, AST_RTP_DTMF},
670         [110] = {1, AST_FORMAT_SPEEX},
671         [111] = {1, AST_FORMAT_G726},
672         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
673 };
674
675 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
676 {
677         int i;
678         if (!rtp)
679                 return;
680
681         for (i = 0; i < MAX_RTP_PT; ++i) {
682                 rtp->current_RTP_PT[i].isAstFormat = 0;
683                 rtp->current_RTP_PT[i].code = 0;
684         }
685
686         rtp->rtp_lookup_code_cache_isAstFormat = 0;
687         rtp->rtp_lookup_code_cache_code = 0;
688         rtp->rtp_lookup_code_cache_result = 0;
689 }
690
691 void ast_rtp_pt_default(struct ast_rtp* rtp) 
692 {
693         int i;
694
695         /* Initialize to default payload types */
696         for (i = 0; i < MAX_RTP_PT; ++i) {
697                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
698                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
699         }
700
701         rtp->rtp_lookup_code_cache_isAstFormat = 0;
702         rtp->rtp_lookup_code_cache_code = 0;
703         rtp->rtp_lookup_code_cache_result = 0;
704 }
705
706 static void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
707 {
708         int i;
709         /* Copy payload types from source to destination */
710         for (i=0; i < MAX_RTP_PT; ++i) {
711                 dest->current_RTP_PT[i].isAstFormat = 
712                         src->current_RTP_PT[i].isAstFormat;
713                 dest->current_RTP_PT[i].code = 
714                         src->current_RTP_PT[i].code; 
715         }
716         dest->rtp_lookup_code_cache_isAstFormat = 0;
717         dest->rtp_lookup_code_cache_code = 0;
718         dest->rtp_lookup_code_cache_result = 0;
719 }
720
721 /*! \brief Get channel driver interface structure */
722 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
723 {
724         struct ast_rtp_protocol *cur = NULL;
725
726         AST_LIST_LOCK(&protos);
727         AST_LIST_TRAVERSE(&protos, cur, list) {
728                 if (cur->type == chan->tech->type)
729                         break;
730         }
731         AST_LIST_UNLOCK(&protos);
732
733         return cur;
734 }
735
736 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src)
737 {
738         struct ast_rtp *destp, *srcp;           /* Audio RTP Channels */
739         struct ast_rtp *vdestp, *vsrcp;         /* Video RTP channels */
740         struct ast_rtp_protocol *destpr, *srcpr;
741         /* Lock channels */
742         ast_channel_lock(dest);
743         while(ast_channel_trylock(src)) {
744                 ast_channel_unlock(dest);
745                 usleep(1);
746                 ast_channel_lock(dest);
747         }
748
749         /* Find channel driver interfaces */
750         destpr = get_proto(dest);
751         srcpr = get_proto(src);
752         if (!destpr) {
753                 if (option_debug)
754                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
755                 ast_channel_unlock(dest);
756                 ast_channel_unlock(src);
757                 return 0;
758         }
759         if (!srcpr) {
760                 if (option_debug)
761                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
762                 ast_channel_unlock(dest);
763                 ast_channel_unlock(src);
764                 return 0;
765         }
766
767         /* Get audio and video interface (if native bridge is possible) */
768         destp = destpr->get_rtp_info(dest);
769         vdestp = (destpr->get_vrtp_info) ? destpr->get_vrtp_info(dest) : NULL;
770         srcp = srcpr->get_rtp_info(src);
771         vsrcp = (srcpr->get_vrtp_info) ? srcpr->get_vrtp_info(src) : NULL;
772
773         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
774         if (!destp || !srcp) {
775                 /* Somebody doesn't want to play... */
776                 ast_channel_unlock(dest);
777                 ast_channel_unlock(src);
778                 return 0;
779         }
780         ast_rtp_pt_copy(destp, srcp);
781         if (vdestp && vsrcp)
782                 ast_rtp_pt_copy(vdestp, vsrcp);
783         ast_channel_unlock(dest);
784         ast_channel_unlock(src);
785         if (option_debug)
786                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
787         return 1;
788 }
789
790 /*! \brief  Make a note of a RTP paymoad type that was seen in a SDP "m=" line.
791  * By default, use the well-known value for this type (although it may 
792  * still be set to a different value by a subsequent "a=rtpmap:" line)
793  */
794 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
795 {
796         if (pt < 0 || pt > MAX_RTP_PT) 
797                 return; /* bogus payload type */
798
799         if (static_RTP_PT[pt].code != 0) {
800                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
801         }
802
803
804 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
805         a SDP "a=rtpmap:" line. */
806 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
807                          char* mimeType, char* mimeSubtype) 
808 {
809         int i;
810
811         if (pt < 0 || pt > MAX_RTP_PT) 
812                 return; /* bogus payload type */
813
814         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
815                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
816                      strcasecmp(mimeType, mimeTypes[i].type) == 0) {
817                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
818                         return;
819                 }
820         }
821
822
823 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
824  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
825 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
826                              int* astFormats, int* nonAstFormats) {
827         int pt;
828
829         *astFormats = *nonAstFormats = 0;
830         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
831                 if (rtp->current_RTP_PT[pt].isAstFormat) {
832                         *astFormats |= rtp->current_RTP_PT[pt].code;
833                 } else {
834                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
835                 }
836         }
837 }
838
839 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
840 {
841         struct rtpPayloadType result;
842
843         result.isAstFormat = result.code = 0;
844         if (pt < 0 || pt > MAX_RTP_PT) 
845                 return result; /* bogus payload type */
846
847         /* Start with the negotiated codecs */
848         result = rtp->current_RTP_PT[pt];
849
850         /* If it doesn't exist, check our static RTP type list, just in case */
851         if (!result.code) 
852                 result = static_RTP_PT[pt];
853         return result;
854 }
855
856 /*! \brief Looks up an RTP code out of our *static* outbound list */
857 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
858
859         int pt;
860
861         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
862                 code == rtp->rtp_lookup_code_cache_code) {
863
864                 /* Use our cached mapping, to avoid the overhead of the loop below */
865                 return rtp->rtp_lookup_code_cache_result;
866         }
867
868         /* Check the dynamic list first */
869         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
870                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
871                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
872                         rtp->rtp_lookup_code_cache_code = code;
873                         rtp->rtp_lookup_code_cache_result = pt;
874                         return pt;
875                 }
876         }
877
878         /* Then the static list */
879         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
880                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
881                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
882                         rtp->rtp_lookup_code_cache_code = code;
883                         rtp->rtp_lookup_code_cache_result = pt;
884                         return pt;
885                 }
886         }
887         return -1;
888 }
889
890 char* ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code) 
891 {
892
893         int i;
894
895         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
896                 if (mimeTypes[i].payloadType.code == code && mimeTypes[i].payloadType.isAstFormat == isAstFormat)
897                         return mimeTypes[i].subtype;
898         }
899         return "";
900 }
901
902 char *ast_rtp_lookup_mime_multiple(char *buf, int size, const int capability, const int isAstFormat)
903 {
904         int format;
905         unsigned len;
906         char *end = buf;
907         char *start = buf;
908
909         if (!buf || !size)
910                 return NULL;
911
912         snprintf(end, size, "0x%x (", capability);
913
914         len = strlen(end);
915         end += len;
916         size -= len;
917         start = end;
918
919         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
920                 if (capability & format) {
921                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format);
922                         snprintf(end, size, "%s|", name);
923                         len = strlen(end);
924                         end += len;
925                         size -= len;
926                 }
927         }
928
929         if (start == end)
930                 snprintf(start, size, "nothing)"); 
931         else if (size > 1)
932                 *(end -1) = ')';
933         
934         return buf;
935 }
936
937 static int rtp_socket(void)
938 {
939         int s;
940         long flags;
941         s = socket(AF_INET, SOCK_DGRAM, 0);
942         if (s > -1) {
943                 flags = fcntl(s, F_GETFL);
944                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
945 #ifdef SO_NO_CHECK
946                 if (nochecksums)
947                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
948 #endif
949         }
950         return s;
951 }
952
953 /*!
954  * \brief Initialize a new RTCP session.
955  * 
956  * \returns The newly initialized RTCP session.
957  */
958 static struct ast_rtcp *ast_rtcp_new(void)
959 {
960         struct ast_rtcp *rtcp;
961
962         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
963                 return NULL;
964         rtcp->s = rtp_socket();
965         rtcp->us.sin_family = AF_INET;
966         if (rtcp->s < 0) {
967                 free(rtcp);
968                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
969                 return NULL;
970         }
971
972         return rtcp;
973 }
974
975 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
976 {
977         struct ast_rtp *rtp;
978         int x;
979         int first;
980         int startplace;
981         
982         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
983                 return NULL;
984         rtp->them.sin_family = AF_INET;
985         rtp->us.sin_family = AF_INET;
986         rtp->s = rtp_socket();
987         rtp->ssrc = ast_random();
988         rtp->seqno = ast_random() & 0xffff;
989         if (rtp->s < 0) {
990                 free(rtp);
991                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
992                 return NULL;
993         }
994         if (sched && rtcpenable) {
995                 rtp->sched = sched;
996                 rtp->rtcp = ast_rtcp_new();
997         }
998         
999         /* Select a random port number in the range of possible RTP */
1000         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1001         x = x & ~1;
1002         /* Save it for future references. */
1003         startplace = x;
1004         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1005         for (;;) {
1006                 /* Must be an even port number by RTP spec */
1007                 rtp->us.sin_port = htons(x);
1008                 rtp->us.sin_addr = addr;
1009                 /* If there's rtcp, initialize it as well. */
1010                 if (rtp->rtcp)
1011                         rtp->rtcp->us.sin_port = htons(x + 1);
1012                 /* Try to bind it/them. */
1013                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1014                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1015                         break;
1016                 if (!first) {
1017                         /* Primary bind succeeded! Gotta recreate it */
1018                         close(rtp->s);
1019                         rtp->s = rtp_socket();
1020                 }
1021                 if (errno != EADDRINUSE) {
1022                         /* We got an error that wasn't expected, abort! */
1023                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1024                         close(rtp->s);
1025                         if (rtp->rtcp) {
1026                                 close(rtp->rtcp->s);
1027                                 free(rtp->rtcp);
1028                         }
1029                         free(rtp);
1030                         return NULL;
1031                 }
1032                 /* The port was used, increment it (by two). */
1033                 x += 2;
1034                 /* Did we go over the limit ? */
1035                 if (x > rtpend)
1036                         /* then, start from the begingig. */
1037                         x = (rtpstart + 1) & ~1;
1038                 /* Check if we reached the place were we started. */
1039                 if (x == startplace) {
1040                         /* If so, there's no ports available. */
1041                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1042                         close(rtp->s);
1043                         if (rtp->rtcp) {
1044                                 close(rtp->rtcp->s);
1045                                 free(rtp->rtcp);
1046                         }
1047                         free(rtp);
1048                         return NULL;
1049                 }
1050         }
1051         if (io && sched && callbackmode) {
1052                 /* Operate this one in a callback mode */
1053                 rtp->sched = sched;
1054                 rtp->io = io;
1055                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1056         }
1057         ast_rtp_pt_default(rtp);
1058         return rtp;
1059 }
1060
1061 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1062 {
1063         struct in_addr ia;
1064
1065         memset(&ia, 0, sizeof(ia));
1066         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1067 }
1068
1069 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1070 {
1071         int res;
1072
1073         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1074                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1075         return res;
1076 }
1077
1078 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1079 {
1080         rtp->them.sin_port = them->sin_port;
1081         rtp->them.sin_addr = them->sin_addr;
1082         if (rtp->rtcp) {
1083                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1084                 rtp->rtcp->them.sin_addr = them->sin_addr;
1085         }
1086         rtp->rxseqno = 0;
1087 }
1088
1089 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1090 {
1091         them->sin_family = AF_INET;
1092         them->sin_port = rtp->them.sin_port;
1093         them->sin_addr = rtp->them.sin_addr;
1094 }
1095
1096 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1097 {
1098         *us = rtp->us;
1099 }
1100
1101 void ast_rtp_stop(struct ast_rtp *rtp)
1102 {
1103         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1104         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1105         if (rtp->rtcp) {
1106                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1107                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1108         }
1109 }
1110
1111 void ast_rtp_reset(struct ast_rtp *rtp)
1112 {
1113         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1114         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1115         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1116         rtp->lastts = 0;
1117         rtp->lastdigitts = 0;
1118         rtp->lastrxts = 0;
1119         rtp->lastividtimestamp = 0;
1120         rtp->lastovidtimestamp = 0;
1121         rtp->lasteventseqn = 0;
1122         rtp->lasteventendseqn = 0;
1123         rtp->lasttxformat = 0;
1124         rtp->lastrxformat = 0;
1125         rtp->dtmfcount = 0;
1126         rtp->dtmfduration = 0;
1127         rtp->seqno = 0;
1128         rtp->rxseqno = 0;
1129 }
1130
1131 void ast_rtp_destroy(struct ast_rtp *rtp)
1132 {
1133         if (rtp->smoother)
1134                 ast_smoother_free(rtp->smoother);
1135         if (rtp->ioid)
1136                 ast_io_remove(rtp->io, rtp->ioid);
1137         if (rtp->s > -1)
1138                 close(rtp->s);
1139         if (rtp->rtcp) {
1140                 close(rtp->rtcp->s);
1141                 free(rtp->rtcp);
1142         }
1143         free(rtp);
1144 }
1145
1146 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1147 {
1148         struct timeval t;
1149         long ms;
1150         if (ast_tvzero(rtp->txcore)) {
1151                 rtp->txcore = ast_tvnow();
1152                 /* Round to 20ms for nice, pretty timestamps */
1153                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1154         }
1155         /* Use previous txcore if available */
1156         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
1157         ms = ast_tvdiff_ms(t, rtp->txcore);
1158         if (ms < 0)
1159                 ms = 0;
1160         /* Use what we just got for next time */
1161         rtp->txcore = t;
1162         return (unsigned int) ms;
1163 }
1164
1165 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1166 {
1167         unsigned int *rtpheader;
1168         int hdrlen = 12;
1169         int res;
1170         int x;
1171         int payload;
1172         char data[256];
1173         char iabuf[INET_ADDRSTRLEN];
1174
1175         if ((digit <= '9') && (digit >= '0'))
1176                 digit -= '0';
1177         else if (digit == '*')
1178                 digit = 10;
1179         else if (digit == '#')
1180                 digit = 11;
1181         else if ((digit >= 'A') && (digit <= 'D')) 
1182                 digit = digit - 'A' + 12;
1183         else if ((digit >= 'a') && (digit <= 'd')) 
1184                 digit = digit - 'a' + 12;
1185         else {
1186                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1187                 return -1;
1188         }
1189         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1190
1191         /* If we have no peer, return immediately */    
1192         if (!rtp->them.sin_addr.s_addr)
1193                 return 0;
1194
1195         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1196         
1197         /* Get a pointer to the header */
1198         rtpheader = (unsigned int *)data;
1199         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
1200         rtpheader[1] = htonl(rtp->lastdigitts);
1201         rtpheader[2] = htonl(rtp->ssrc); 
1202         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1203         for (x = 0; x < 6; x++) {
1204                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1205                         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
1206                         if (res < 0) 
1207                                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
1208                                         ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1209                                         ntohs(rtp->them.sin_port), strerror(errno));
1210                         if (rtp_debug_test_addr(&rtp->them))
1211                                 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n",
1212                                             ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr),
1213                                             ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1214                 }
1215                 /* Sequence number of last two end packets does not get incremented */
1216                 if (x < 3)
1217                         rtp->seqno++;
1218                 /* Clear marker bit and set seqno */
1219                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
1220                 /* For the last three packets, set the duration and the end bit */
1221                 if (x == 2) {
1222 #if 0
1223                         /* No, this is wrong...  Do not increment lastdigitts, that's not according
1224                            to the RFC, as best we can determine */
1225                         rtp->lastdigitts++; /* or else the SPA3000 will click instead of beeping... */
1226                         rtpheader[1] = htonl(rtp->lastdigitts);
1227 #endif                  
1228                         /* Make duration 800 (100ms) */
1229                         rtpheader[3] |= htonl((800));
1230                         /* Set the End bit */
1231                         rtpheader[3] |= htonl((1 << 23));
1232                 }
1233         }
1234         /* Increment the digit timestamp by 120ms, to ensure that digits
1235            sent sequentially with no intervening non-digit packets do not
1236            get sent with the same timestamp, and that sequential digits
1237            have some 'dead air' in between them
1238         */
1239         rtp->lastdigitts += 960;
1240         /* Increment the sequence number to reflect the last packet
1241            that was sent
1242         */
1243         rtp->seqno++;
1244         return 0;
1245 }
1246
1247 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1248 {
1249         unsigned int *rtpheader;
1250         int hdrlen = 12;
1251         int res;
1252         int payload;
1253         char data[256];
1254         char iabuf[INET_ADDRSTRLEN];
1255         level = 127 - (level & 0x7f);
1256         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1257
1258         /* If we have no peer, return immediately */    
1259         if (!rtp->them.sin_addr.s_addr)
1260                 return 0;
1261
1262         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
1263
1264         /* Get a pointer to the header */
1265         rtpheader = (unsigned int *)data;
1266         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1267         rtpheader[1] = htonl(rtp->lastts);
1268         rtpheader[2] = htonl(rtp->ssrc); 
1269         data[12] = level;
1270         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1271                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1272                 if (res <0) 
1273                         ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1274                 if(rtp_debug_test_addr(&rtp->them))
1275                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1276                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1277                    
1278         }
1279         return 0;
1280 }
1281
1282 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1283 {
1284         unsigned char *rtpheader;
1285         char iabuf[INET_ADDRSTRLEN];
1286         int hdrlen = 12;
1287         int res;
1288         unsigned int ms;
1289         int pred;
1290         int mark = 0;
1291
1292         ms = calc_txstamp(rtp, &f->delivery);
1293         /* Default prediction */
1294         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1295                 pred = rtp->lastts + f->samples;
1296
1297                 /* Re-calculate last TS */
1298                 rtp->lastts = rtp->lastts + ms * 8;
1299                 if (ast_tvzero(f->delivery)) {
1300                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1301                            and if so, go with our prediction */
1302                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1303                                 rtp->lastts = pred;
1304                         else {
1305                                 if (option_debug > 2)
1306                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1307                                 mark = 1;
1308                         }
1309                 }
1310         } else {
1311                 mark = f->subclass & 0x1;
1312                 pred = rtp->lastovidtimestamp + f->samples;
1313                 /* Re-calculate last TS */
1314                 rtp->lastts = rtp->lastts + ms * 90;
1315                 /* If it's close to our prediction, go for it */
1316                 if (ast_tvzero(f->delivery)) {
1317                         if (abs(rtp->lastts - pred) < 7200) {
1318                                 rtp->lastts = pred;
1319                                 rtp->lastovidtimestamp += f->samples;
1320                         } else {
1321                                 if (option_debug > 2)
1322                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
1323                                 rtp->lastovidtimestamp = rtp->lastts;
1324                         }
1325                 }
1326         }
1327         /* If the timestamp for non-digit packets has moved beyond the timestamp
1328            for digits, update the digit timestamp.
1329         */
1330         if (rtp->lastts > rtp->lastdigitts)
1331                 rtp->lastdigitts = rtp->lastts;
1332
1333         /* Get a pointer to the header */
1334         rtpheader = (unsigned char *)(f->data - hdrlen);
1335
1336         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1337         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1338         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
1339
1340         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1341                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1342                 if (res <0) {
1343                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1344                                 ast_log(LOG_DEBUG, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1345                         } else if ((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) {
1346                                 /* Only give this error message once if we are not RTP debugging */
1347                                 if (option_debug || rtpdebug)
1348                                         ast_log(LOG_DEBUG, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1349                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
1350                         }
1351                 }
1352                                 
1353                 if(rtp_debug_test_addr(&rtp->them))
1354                         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %u, ts %u, len %u)\n"
1355                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1356         }
1357
1358         rtp->seqno++;
1359
1360         return 0;
1361 }
1362
1363 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1364 {
1365         struct ast_frame *f;
1366         int codec;
1367         int hdrlen = 12;
1368         int subclass;
1369         
1370
1371         /* If we have no peer, return immediately */    
1372         if (!rtp->them.sin_addr.s_addr)
1373                 return 0;
1374
1375         /* If there is no data length, return immediately */
1376         if (!_f->datalen) 
1377                 return 0;
1378         
1379         /* Make sure we have enough space for RTP header */
1380         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1381                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1382                 return -1;
1383         }
1384
1385         subclass = _f->subclass;
1386         if (_f->frametype == AST_FRAME_VIDEO)
1387                 subclass &= ~0x1;
1388
1389         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1390         if (codec < 0) {
1391                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1392                 return -1;
1393         }
1394
1395         if (rtp->lasttxformat != subclass) {
1396                 /* New format, reset the smoother */
1397                 if (option_debug)
1398                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1399                 rtp->lasttxformat = subclass;
1400                 if (rtp->smoother)
1401                         ast_smoother_free(rtp->smoother);
1402                 rtp->smoother = NULL;
1403         }
1404
1405
1406         switch(subclass) {
1407         case AST_FORMAT_SLINEAR:
1408                 if (!rtp->smoother) {
1409                         rtp->smoother = ast_smoother_new(320);
1410                 }
1411                 if (!rtp->smoother) {
1412                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1413                         return -1;
1414                 }
1415                 ast_smoother_feed_be(rtp->smoother, _f);
1416                 
1417                 while((f = ast_smoother_read(rtp->smoother)))
1418                         ast_rtp_raw_write(rtp, f, codec);
1419                 break;
1420         case AST_FORMAT_ULAW:
1421         case AST_FORMAT_ALAW:
1422                 if (!rtp->smoother) {
1423                         rtp->smoother = ast_smoother_new(160);
1424                 }
1425                 if (!rtp->smoother) {
1426                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1427                         return -1;
1428                 }
1429                 ast_smoother_feed(rtp->smoother, _f);
1430                 
1431                 while((f = ast_smoother_read(rtp->smoother)))
1432                         ast_rtp_raw_write(rtp, f, codec);
1433                 break;
1434         case AST_FORMAT_ADPCM:
1435         case AST_FORMAT_G726:
1436                 if (!rtp->smoother) {
1437                         rtp->smoother = ast_smoother_new(80);
1438                 }
1439                 if (!rtp->smoother) {
1440                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1441                         return -1;
1442                 }
1443                 ast_smoother_feed(rtp->smoother, _f);
1444                 
1445                 while((f = ast_smoother_read(rtp->smoother)))
1446                         ast_rtp_raw_write(rtp, f, codec);
1447                 break;
1448         case AST_FORMAT_G729A:
1449                 if (!rtp->smoother) {
1450                         rtp->smoother = ast_smoother_new(20);
1451                         if (rtp->smoother)
1452                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1453                 }
1454                 if (!rtp->smoother) {
1455                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1456                         return -1;
1457                 }
1458                 ast_smoother_feed(rtp->smoother, _f);
1459                 
1460                 while((f = ast_smoother_read(rtp->smoother)))
1461                         ast_rtp_raw_write(rtp, f, codec);
1462                 break;
1463         case AST_FORMAT_GSM:
1464                 if (!rtp->smoother) {
1465                         rtp->smoother = ast_smoother_new(33);
1466                 }
1467                 if (!rtp->smoother) {
1468                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1469                         return -1;
1470                 }
1471                 ast_smoother_feed(rtp->smoother, _f);
1472                 while((f = ast_smoother_read(rtp->smoother)))
1473                         ast_rtp_raw_write(rtp, f, codec);
1474                 break;
1475         case AST_FORMAT_ILBC:
1476                 if (!rtp->smoother) {
1477                         rtp->smoother = ast_smoother_new(50);
1478                 }
1479                 if (!rtp->smoother) {
1480                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1481                         return -1;
1482                 }
1483                 ast_smoother_feed(rtp->smoother, _f);
1484                 while((f = ast_smoother_read(rtp->smoother)))
1485                         ast_rtp_raw_write(rtp, f, codec);
1486                 break;
1487         default:        
1488                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1489                 /* fall through to... */
1490         case AST_FORMAT_H261:
1491         case AST_FORMAT_H263:
1492         case AST_FORMAT_H263_PLUS:
1493         case AST_FORMAT_H264:
1494         case AST_FORMAT_G723_1:
1495         case AST_FORMAT_LPC10:
1496         case AST_FORMAT_SPEEX:
1497                 /* Don't buffer outgoing frames; send them one-per-packet: */
1498                 if (_f->offset < hdrlen) {
1499                         f = ast_frdup(_f);
1500                 } else {
1501                         f = _f;
1502                 }
1503                 ast_rtp_raw_write(rtp, f, codec);
1504         }
1505                 
1506         return 0;
1507 }
1508
1509 /*! \brief Unregister interface to channel driver */
1510 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1511 {
1512         AST_LIST_LOCK(&protos);
1513         AST_LIST_REMOVE(&protos, proto, list);
1514         AST_LIST_UNLOCK(&protos);
1515 }
1516
1517 /*! \brief Register interface to channel driver */
1518 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1519 {
1520         struct ast_rtp_protocol *cur;
1521
1522         AST_LIST_LOCK(&protos);
1523         AST_LIST_TRAVERSE(&protos, cur, list) { 
1524                 if (!strcmp(cur->type, proto->type)) {
1525                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1526                         AST_LIST_UNLOCK(&protos);
1527                         return -1;
1528                 }
1529         }
1530         AST_LIST_INSERT_HEAD(&protos, proto, list);
1531         AST_LIST_UNLOCK(&protos);
1532         
1533         return 0;
1534 }
1535
1536 /*! \brief Bridge calls. If possible and allowed, initiate
1537         re-invite so the peers exchange media directly outside 
1538         of Asterisk. */
1539 enum ast_bridge_result ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
1540 {
1541         struct ast_frame *f;
1542         struct ast_channel *who, *other, *cs[3];
1543         struct ast_rtp *p0, *p1;                /* Audio RTP Channels */
1544         struct ast_rtp *vp0, *vp1;              /* Video RTP channels */
1545         struct ast_rtp_protocol *pr0, *pr1;
1546         struct sockaddr_in ac0, ac1;
1547         struct sockaddr_in vac0, vac1;
1548         struct sockaddr_in t0, t1;
1549         struct sockaddr_in vt0, vt1;
1550         char iabuf[INET_ADDRSTRLEN];
1551         
1552         void *pvt0, *pvt1;
1553         int codec0,codec1, oldcodec0, oldcodec1;
1554         
1555         memset(&vt0, 0, sizeof(vt0));
1556         memset(&vt1, 0, sizeof(vt1));
1557         memset(&vac0, 0, sizeof(vac0));
1558         memset(&vac1, 0, sizeof(vac1));
1559
1560         /* if need DTMF, cant native bridge */
1561         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1562                 return AST_BRIDGE_FAILED_NOWARN;
1563
1564         /* Lock channels */
1565         ast_channel_lock(c0);
1566         while(ast_channel_trylock(c1)) {
1567                 ast_channel_unlock(c0);
1568                 usleep(1);
1569                 ast_channel_lock(c0);
1570         }
1571
1572         /* Find channel driver interfaces */
1573         pr0 = get_proto(c0);
1574         pr1 = get_proto(c1);
1575         if (!pr0) {
1576                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1577                 ast_channel_unlock(c0);
1578                 ast_channel_unlock(c1);
1579                 return AST_BRIDGE_FAILED;
1580         }
1581         if (!pr1) {
1582                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1583                 ast_channel_unlock(c0);
1584                 ast_channel_unlock(c1);
1585                 return AST_BRIDGE_FAILED;
1586         }
1587
1588         /* Get channel specific interface structures */
1589         pvt0 = c0->tech_pvt;
1590         pvt1 = c1->tech_pvt;
1591
1592         /* Get audio and video interface (if native bridge is possible) */
1593         p0 = pr0->get_rtp_info(c0);
1594         vp0 = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0) : NULL;
1595         p1 = pr1->get_rtp_info(c1);
1596         vp1 = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1) : NULL;
1597
1598         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1599         if (!p0 || !p1) {
1600                 /* Somebody doesn't want to play... */
1601                 ast_channel_unlock(c0);
1602                 ast_channel_unlock(c1);
1603                 return AST_BRIDGE_FAILED_NOWARN;
1604         }
1605         /* Get codecs from both sides */
1606         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
1607         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
1608         if (pr0->get_codec && pr1->get_codec) {
1609                 /* Hey, we can't do reinvite if both parties speak different codecs */
1610                 if (!(codec0 & codec1)) {
1611                         if (option_debug)
1612                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
1613                         ast_channel_unlock(c0);
1614                         ast_channel_unlock(c1);
1615                         return AST_BRIDGE_FAILED_NOWARN;
1616                 }
1617         }
1618
1619         if (option_verbose > 2) 
1620                 ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
1621
1622         /* Ok, we should be able to redirect the media. Start with one channel */
1623         if (pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
1624                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1625         else {
1626                 /* Store RTP peer */
1627                 ast_rtp_get_peer(p1, &ac1);
1628                 if (vp1)
1629                         ast_rtp_get_peer(vp1, &vac1);
1630         }
1631         /* Then test the other channel */
1632         if (pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
1633                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1634         else {
1635                 /* Store RTP peer */
1636                 ast_rtp_get_peer(p0, &ac0);
1637                 if (vp0)
1638                         ast_rtp_get_peer(vp0, &vac0);
1639         }
1640         ast_channel_unlock(c0);
1641         ast_channel_unlock(c1);
1642         /* External RTP Bridge up, now loop and see if something happes that force us to take the
1643                 media back to Asterisk */
1644         cs[0] = c0;
1645         cs[1] = c1;
1646         cs[2] = NULL;
1647         oldcodec0 = codec0;
1648         oldcodec1 = codec1;
1649         for (;;) {
1650                 /* Check if something changed... */
1651                 if ((c0->tech_pvt != pvt0)  ||
1652                         (c1->tech_pvt != pvt1) ||
1653                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1654                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1655                                 if (c0->tech_pvt == pvt0) {
1656                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
1657                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
1658                                 }
1659                                 if (c1->tech_pvt == pvt1) {
1660                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
1661                                                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
1662                                 }
1663                                 return AST_BRIDGE_RETRY;
1664                 }
1665                 /* Now check if they have changed address */
1666                 ast_rtp_get_peer(p1, &t1);
1667                 ast_rtp_get_peer(p0, &t0);
1668                 if (pr0->get_codec)
1669                         codec0 = pr0->get_codec(c0);
1670                 if (pr1->get_codec)
1671                         codec1 = pr1->get_codec(c1);
1672                 if (vp1)
1673                         ast_rtp_get_peer(vp1, &vt1);
1674                 if (vp0)
1675                         ast_rtp_get_peer(vp0, &vt0);
1676                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
1677                         if (option_debug > 1) {
1678                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1679                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
1680                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
1681                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
1682                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1683                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
1684                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1685                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
1686                         }
1687                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE))) 
1688                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1689                         memcpy(&ac1, &t1, sizeof(ac1));
1690                         memcpy(&vac1, &vt1, sizeof(vac1));
1691                         oldcodec1 = codec1;
1692                 }
1693                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1694                         if (option_debug) {
1695                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1696                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
1697                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1698                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
1699                         }
1700                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
1701                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1702                         memcpy(&ac0, &t0, sizeof(ac0));
1703                         memcpy(&vac0, &vt0, sizeof(vac0));
1704                         oldcodec0 = codec0;
1705                 }
1706                 who = ast_waitfor_n(cs, 2, &timeoutms);
1707                 if (!who) {
1708                         if (!timeoutms) 
1709                                 return AST_BRIDGE_RETRY;
1710                         if (option_debug)
1711                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1712                         /* check for hangup / whentohangup */
1713                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1714                                 break;
1715                         continue;
1716                 }
1717                 f = ast_read(who);
1718                 other = (who == c0) ? c1 : c0; /* the other channel */
1719                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1720                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1721                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1722                         /* breaking out of the bridge. */
1723                         *fo = f;
1724                         *rc = who;
1725                         if (option_debug)
1726                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1727                         if ((c0->tech_pvt == pvt0)) {
1728                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0)) 
1729                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
1730                         }
1731                         if ((c1->tech_pvt == pvt1)) {
1732                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0)) 
1733                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
1734                         }
1735                         return AST_BRIDGE_COMPLETE;
1736                 } else if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
1737                         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
1738                             (f->subclass == AST_CONTROL_VIDUPDATE)) {
1739                                 ast_indicate(other, f->subclass);
1740                                 ast_frfree(f);
1741                         } else {
1742                                 *fo = f;
1743                                 *rc = who;
1744                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
1745                                 return AST_BRIDGE_COMPLETE;
1746                         }
1747                 } else {
1748                         if ((f->frametype == AST_FRAME_DTMF) || 
1749                                 (f->frametype == AST_FRAME_VOICE) || 
1750                                 (f->frametype == AST_FRAME_VIDEO)) {
1751                                 /* Forward voice or DTMF frames if they happen upon us */
1752                                 ast_write(other, f);
1753                         }
1754                         ast_frfree(f);
1755                 }
1756                 /* Swap priority not that it's a big deal at this point */
1757                 cs[2] = cs[0];
1758                 cs[0] = cs[1];
1759                 cs[1] = cs[2];
1760                 
1761         }
1762         return AST_BRIDGE_FAILED;
1763 }
1764
1765 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
1766 {
1767         struct hostent *hp;
1768         struct ast_hostent ahp;
1769         char iabuf[INET_ADDRSTRLEN];
1770         int port = 0;
1771         char *p, *arg;
1772
1773         if (argc != 4)
1774                 return RESULT_SHOWUSAGE;
1775         arg = argv[3];
1776         p = strstr(arg, ":");
1777         if (p) {
1778                 *p = '\0';
1779                 p++;
1780                 port = atoi(p);
1781         }
1782         hp = ast_gethostbyname(arg, &ahp);
1783         if (hp == NULL)
1784                 return RESULT_SHOWUSAGE;
1785         rtpdebugaddr.sin_family = AF_INET;
1786         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
1787         rtpdebugaddr.sin_port = htons(port);
1788         if (port == 0)
1789                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
1790         else
1791                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
1792         rtpdebug = 1;
1793         return RESULT_SUCCESS;
1794 }
1795
1796 static int rtp_do_debug(int fd, int argc, char *argv[])
1797 {
1798         if(argc != 2) {
1799                 if(argc != 4)
1800                         return RESULT_SHOWUSAGE;
1801                 return rtp_do_debug_ip(fd, argc, argv);
1802         }
1803         rtpdebug = 1;
1804         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
1805         ast_cli(fd, "RTP Debugging Enabled\n");
1806         return RESULT_SUCCESS;
1807 }
1808    
1809 static int rtp_no_debug(int fd, int argc, char *argv[])
1810 {
1811         if(argc !=3)
1812                 return RESULT_SHOWUSAGE;
1813         rtpdebug = 0;
1814         ast_cli(fd,"RTP Debugging Disabled\n");
1815         return RESULT_SUCCESS;
1816 }
1817
1818 static char debug_usage[] =
1819   "Usage: rtp debug [ip host[:port]]\n"
1820   "       Enable dumping of all RTP packets to and from host.\n";
1821
1822 static char no_debug_usage[] =
1823   "Usage: rtp no debug\n"
1824   "       Disable all RTP debugging\n";
1825
1826 static struct ast_cli_entry  cli_debug_ip =
1827 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
1828
1829 static struct ast_cli_entry  cli_debug =
1830 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
1831
1832 static struct ast_cli_entry  cli_no_debug =
1833 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
1834
1835 int ast_rtp_reload(void)
1836 {
1837         struct ast_config *cfg;
1838         char *s;
1839
1840         rtpstart = 5000;
1841         rtpend = 31000;
1842         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
1843         cfg = ast_config_load("rtp.conf");
1844         if (cfg) {
1845                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1846                         rtpstart = atoi(s);
1847                         if (rtpstart < 1024)
1848                                 rtpstart = 1024;
1849                         if (rtpstart > 65535)
1850                                 rtpstart = 65535;
1851                 }
1852                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1853                         rtpend = atoi(s);
1854                         if (rtpend < 1024)
1855                                 rtpend = 1024;
1856                         if (rtpend > 65535)
1857                                 rtpend = 65535;
1858                 }
1859                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
1860 #ifdef SO_NO_CHECK
1861                         if (ast_false(s))
1862                                 nochecksums = 1;
1863                         else
1864                                 nochecksums = 0;
1865 #else
1866                         if (ast_false(s))
1867                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
1868 #endif
1869                 }
1870                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
1871                         dtmftimeout = atoi(s);
1872                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
1873                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
1874                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
1875                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
1876                         };
1877                 }
1878                 ast_config_destroy(cfg);
1879         }
1880         if (rtpstart >= rtpend) {
1881                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
1882                 rtpstart = 5000;
1883                 rtpend = 31000;
1884         }
1885         if (option_verbose > 1)
1886                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1887         return 0;
1888 }
1889
1890 /*! \brief Initialize the RTP system in Asterisk */
1891 void ast_rtp_init(void)
1892 {
1893         ast_cli_register(&cli_debug);
1894         ast_cli_register(&cli_debug_ip);
1895         ast_cli_register(&cli_no_debug);
1896         ast_rtp_reload();
1897 }