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