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