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