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