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