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