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