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