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