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