Don't use deprecated "2" location for G.726 (rfc3551)
[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   {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
670 };
671
672 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
673    also, our own choices for dynamic payload types.  This is our master
674    table for transmission */
675 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
676   [0] = {1, AST_FORMAT_ULAW},
677 #ifdef USE_DEPRECATED_G726
678   [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
679 #endif
680   [3] = {1, AST_FORMAT_GSM},
681   [4] = {1, AST_FORMAT_G723_1},
682   [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
683   [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
684   [7] = {1, AST_FORMAT_LPC10},
685   [8] = {1, AST_FORMAT_ALAW},
686   [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
687   [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
688   [13] = {0, AST_RTP_CN},
689   [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
690   [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
691   [18] = {1, AST_FORMAT_G729A},
692   [19] = {0, AST_RTP_CN},               /* Also used for CN */
693   [26] = {1, AST_FORMAT_JPEG},
694   [31] = {1, AST_FORMAT_H261},
695   [34] = {1, AST_FORMAT_H263},
696   [103] = {1, AST_FORMAT_H263_PLUS},
697   [97] = {1, AST_FORMAT_ILBC},
698   [101] = {0, AST_RTP_DTMF},
699   [110] = {1, AST_FORMAT_SPEEX},
700   [111] = {1, AST_FORMAT_G726},
701   [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
702 };
703
704 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
705 {
706         int i;
707
708         for (i = 0; i < MAX_RTP_PT; ++i) {
709                 rtp->current_RTP_PT[i].isAstFormat = 0;
710                 rtp->current_RTP_PT[i].code = 0;
711         }
712
713         rtp->rtp_lookup_code_cache_isAstFormat = 0;
714         rtp->rtp_lookup_code_cache_code = 0;
715         rtp->rtp_lookup_code_cache_result = 0;
716 }
717
718 void ast_rtp_pt_default(struct ast_rtp* rtp) 
719 {
720         int i;
721
722         /* Initialize to default payload types */
723         for (i = 0; i < MAX_RTP_PT; ++i) {
724                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
725                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
726         }
727
728         rtp->rtp_lookup_code_cache_isAstFormat = 0;
729         rtp->rtp_lookup_code_cache_code = 0;
730         rtp->rtp_lookup_code_cache_result = 0;
731 }
732
733 /* Make a note of a RTP payload type that was seen in a SDP "m=" line. */
734 /* By default, use the well-known value for this type (although it may */
735 /* still be set to a different value by a subsequent "a=rtpmap:" line): */
736 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) {
737         if (pt < 0 || pt > MAX_RTP_PT) 
738                 return; /* bogus payload type */
739
740         if (static_RTP_PT[pt].code != 0) {
741                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
742         }
743
744
745 /* Make a note of a RTP payload type (with MIME type) that was seen in */
746 /* a SDP "a=rtpmap:" line. */
747 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
748                          char* mimeType, char* mimeSubtype) {
749         int i;
750
751         if (pt < 0 || pt > MAX_RTP_PT) 
752                         return; /* bogus payload type */
753
754         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
755                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
756                      strcasecmp(mimeType, mimeTypes[i].type) == 0) {
757                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
758                 return;
759                 }
760         }
761
762
763 /* Return the union of all of the codecs that were set by rtp_set...() calls */
764 /* They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
765 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
766                              int* astFormats, int* nonAstFormats) {
767         int pt;
768
769         *astFormats = *nonAstFormats = 0;
770         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
771                 if (rtp->current_RTP_PT[pt].isAstFormat) {
772                         *astFormats |= rtp->current_RTP_PT[pt].code;
773                 } else {
774                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
775                 }
776         }
777 }
778
779 void ast_rtp_offered_from_local(struct ast_rtp* rtp, int local) {
780         if (rtp)
781                 rtp->rtp_offered_from_local = local;
782         else
783                 ast_log(LOG_WARNING, "rtp structure is null\n");
784 }
785
786 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
787 {
788         struct rtpPayloadType result;
789
790         result.isAstFormat = result.code = 0;
791         if (pt < 0 || pt > MAX_RTP_PT) 
792                 return result; /* bogus payload type */
793
794         /* Start with the negotiated codecs */
795         if (!rtp->rtp_offered_from_local)
796                 result = rtp->current_RTP_PT[pt];
797
798         /* If it doesn't exist, check our static RTP type list, just in case */
799         if (!result.code) 
800                 result = static_RTP_PT[pt];
801         return result;
802 }
803
804 /* Looks up an RTP code out of our *static* outbound list */
805 int ast_rtp_lookup_code(struct ast_rtp* rtp, int isAstFormat, int code) {
806
807         int pt;
808
809         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
810                 code == rtp->rtp_lookup_code_cache_code) {
811
812                 /* Use our cached mapping, to avoid the overhead of the loop below */
813                 return rtp->rtp_lookup_code_cache_result;
814         }
815
816         /* Check the dynamic list first */
817         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
818                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
819                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
820                         rtp->rtp_lookup_code_cache_code = code;
821                         rtp->rtp_lookup_code_cache_result = pt;
822                         return pt;
823                 }
824         }
825
826         /* Then the static list */
827         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
828                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
829                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
830                         rtp->rtp_lookup_code_cache_code = code;
831                         rtp->rtp_lookup_code_cache_result = pt;
832                         return pt;
833                 }
834         }
835         return -1;
836 }
837
838 char* ast_rtp_lookup_mime_subtype(int isAstFormat, int code) {
839
840         int i;
841
842         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
843         if (mimeTypes[i].payloadType.code == code && mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
844                 return mimeTypes[i].subtype;
845                 }
846         }
847         return "";
848 }
849
850 static int rtp_socket(void)
851 {
852         int s;
853         long flags;
854         s = socket(AF_INET, SOCK_DGRAM, 0);
855         if (s > -1) {
856                 flags = fcntl(s, F_GETFL);
857                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
858 #ifdef SO_NO_CHECK
859                 if (checksums) {
860                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &checksums, sizeof(checksums));
861                 }
862 #endif
863         }
864         return s;
865 }
866
867 static struct ast_rtcp *ast_rtcp_new(void)
868 {
869         struct ast_rtcp *rtcp;
870         rtcp = malloc(sizeof(struct ast_rtcp));
871         if (!rtcp)
872                 return NULL;
873         memset(rtcp, 0, sizeof(struct ast_rtcp));
874         rtcp->s = rtp_socket();
875         rtcp->us.sin_family = AF_INET;
876         if (rtcp->s < 0) {
877                 free(rtcp);
878                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
879                 return NULL;
880         }
881         return rtcp;
882 }
883
884 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
885 {
886         struct ast_rtp *rtp;
887         int x;
888         int first;
889         int startplace;
890         rtp = malloc(sizeof(struct ast_rtp));
891         if (!rtp)
892                 return NULL;
893         memset(rtp, 0, sizeof(struct ast_rtp));
894         rtp->them.sin_family = AF_INET;
895         rtp->us.sin_family = AF_INET;
896         rtp->s = rtp_socket();
897         rtp->ssrc = rand();
898         rtp->seqno = rand() & 0xffff;
899         if (rtp->s < 0) {
900                 free(rtp);
901                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
902                 return NULL;
903         }
904         if (sched && rtcpenable) {
905                 rtp->sched = sched;
906                 rtp->rtcp = ast_rtcp_new();
907         }
908         /* Find us a place */
909         x = (rand() % (rtpend-rtpstart)) + rtpstart;
910         x = x & ~1;
911         startplace = x;
912         for (;;) {
913                 /* Must be an even port number by RTP spec */
914                 rtp->us.sin_port = htons(x);
915                 rtp->us.sin_addr = addr;
916                 if (rtp->rtcp)
917                         rtp->rtcp->us.sin_port = htons(x + 1);
918                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
919                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
920                         break;
921                 if (!first) {
922                         /* Primary bind succeeded! Gotta recreate it */
923                         close(rtp->s);
924                         rtp->s = rtp_socket();
925                 }
926                 if (errno != EADDRINUSE) {
927                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
928                         close(rtp->s);
929                         if (rtp->rtcp) {
930                                 close(rtp->rtcp->s);
931                                 free(rtp->rtcp);
932                         }
933                         free(rtp);
934                         return NULL;
935                 }
936                 x += 2;
937                 if (x > rtpend)
938                         x = (rtpstart + 1) & ~1;
939                 if (x == startplace) {
940                         ast_log(LOG_ERROR, "No RTP ports remaining\n");
941                         close(rtp->s);
942                         if (rtp->rtcp) {
943                                 close(rtp->rtcp->s);
944                                 free(rtp->rtcp);
945                         }
946                         free(rtp);
947                         return NULL;
948                 }
949         }
950         if (io && sched && callbackmode) {
951                 /* Operate this one in a callback mode */
952                 rtp->sched = sched;
953                 rtp->io = io;
954                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
955         }
956         ast_rtp_pt_default(rtp);
957         return rtp;
958 }
959
960 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
961 {
962         struct in_addr ia;
963
964         memset(&ia, 0, sizeof(ia));
965         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
966 }
967
968 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
969 {
970         int res;
971
972         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
973                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
974         return res;
975 }
976
977 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
978 {
979         rtp->them.sin_port = them->sin_port;
980         rtp->them.sin_addr = them->sin_addr;
981         if (rtp->rtcp) {
982                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
983                 rtp->rtcp->them.sin_addr = them->sin_addr;
984         }
985         rtp->rxseqno = 0;
986 }
987
988 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
989 {
990         them->sin_family = AF_INET;
991         them->sin_port = rtp->them.sin_port;
992         them->sin_addr = rtp->them.sin_addr;
993 }
994
995 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
996 {
997         memcpy(us, &rtp->us, sizeof(rtp->us));
998 }
999
1000 void ast_rtp_stop(struct ast_rtp *rtp)
1001 {
1002         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1003         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1004         if (rtp->rtcp) {
1005                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1006                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1007         }
1008 }
1009
1010 void ast_rtp_reset(struct ast_rtp *rtp)
1011 {
1012         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1013         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1014         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1015         rtp->lastts = 0;
1016         rtp->lastrxts = 0;
1017         rtp->lastividtimestamp = 0;
1018         rtp->lastovidtimestamp = 0;
1019         rtp->lasteventseqn = 0;
1020         rtp->lasttxformat = 0;
1021         rtp->lastrxformat = 0;
1022         rtp->dtmfcount = 0;
1023         rtp->dtmfduration = 0;
1024         rtp->seqno = 0;
1025         rtp->rxseqno = 0;
1026 }
1027
1028 void ast_rtp_destroy(struct ast_rtp *rtp)
1029 {
1030         if (rtp->smoother)
1031                 ast_smoother_free(rtp->smoother);
1032         if (rtp->ioid)
1033                 ast_io_remove(rtp->io, rtp->ioid);
1034         if (rtp->s > -1)
1035                 close(rtp->s);
1036         if (rtp->rtcp) {
1037                 close(rtp->rtcp->s);
1038                 free(rtp->rtcp);
1039         }
1040         free(rtp);
1041 }
1042
1043 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1044 {
1045         struct timeval now;
1046         unsigned int ms;
1047         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
1048                 gettimeofday(&rtp->txcore, NULL);
1049                 /* Round to 20ms for nice, pretty timestamps */
1050                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1051         }
1052         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
1053                 /* Use previous txcore */
1054                 ms = (delivery->tv_sec - rtp->txcore.tv_sec) * 1000;
1055                 ms += (1000000 + delivery->tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
1056                 rtp->txcore.tv_sec = delivery->tv_sec;
1057                 rtp->txcore.tv_usec = delivery->tv_usec;
1058         } else {
1059                 gettimeofday(&now, NULL);
1060                 ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
1061                 ms += (1000000 + now.tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
1062                 /* Use what we just got for next time */
1063                 rtp->txcore.tv_sec = now.tv_sec;
1064                 rtp->txcore.tv_usec = now.tv_usec;
1065         }
1066         return ms;
1067 }
1068
1069 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1070 {
1071         unsigned int *rtpheader;
1072         int hdrlen = 12;
1073         int res;
1074         int x;
1075         int payload;
1076         char data[256];
1077         char iabuf[INET_ADDRSTRLEN];
1078
1079         if ((digit <= '9') && (digit >= '0'))
1080                 digit -= '0';
1081         else if (digit == '*')
1082                 digit = 10;
1083         else if (digit == '#')
1084                 digit = 11;
1085         else if ((digit >= 'A') && (digit <= 'D')) 
1086                 digit = digit - 'A' + 12;
1087         else if ((digit >= 'a') && (digit <= 'd')) 
1088                 digit = digit - 'a' + 12;
1089         else {
1090                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1091                 return -1;
1092         }
1093         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1094
1095         /* If we have no peer, return immediately */    
1096         if (!rtp->them.sin_addr.s_addr)
1097                 return 0;
1098
1099         gettimeofday(&rtp->dtmfmute, NULL);
1100         rtp->dtmfmute.tv_usec += (500 * 1000);
1101         if (rtp->dtmfmute.tv_usec > 1000000) {
1102                 rtp->dtmfmute.tv_usec -= 1000000;
1103                 rtp->dtmfmute.tv_sec += 1;
1104         }
1105         
1106         /* Get a pointer to the header */
1107         rtpheader = (unsigned int *)data;
1108         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1109         rtpheader[1] = htonl(rtp->lastts);
1110         rtpheader[2] = htonl(rtp->ssrc); 
1111         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1112         for (x=0;x<6;x++) {
1113                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1114                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1115                         if (res <0) 
1116                                 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));
1117                         if(rtp_debug_test_addr(&rtp->them))
1118                                 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1119                                                 , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1120                    
1121                 }
1122                 if (x == 2) {
1123                         /* Clear marker bit and increment seqno */
1124                         rtpheader[0] = htonl((2 << 30)  | (payload << 16) | (rtp->seqno++));
1125                         /* Make duration 800 (100ms) */
1126                         rtpheader[3] |= htonl((800));
1127                         /* Set the End bit for the last 3 */
1128                         rtpheader[3] |= htonl((1 << 23));
1129                 } else if ( x < 5) {
1130                         rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno++));
1131                 }
1132         }
1133         return 0;
1134 }
1135
1136 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1137 {
1138         unsigned int *rtpheader;
1139         int hdrlen = 12;
1140         int res;
1141         int payload;
1142         char data[256];
1143         char iabuf[INET_ADDRSTRLEN];
1144         level = 127 - (level & 0x7f);
1145         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1146
1147         /* If we have no peer, return immediately */    
1148         if (!rtp->them.sin_addr.s_addr)
1149                 return 0;
1150
1151         gettimeofday(&rtp->dtmfmute, NULL);
1152         rtp->dtmfmute.tv_usec += (500 * 1000);
1153         if (rtp->dtmfmute.tv_usec > 1000000) {
1154                 rtp->dtmfmute.tv_usec -= 1000000;
1155                 rtp->dtmfmute.tv_sec += 1;
1156         }
1157         
1158         /* Get a pointer to the header */
1159         rtpheader = (unsigned int *)data;
1160         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1161         rtpheader[1] = htonl(rtp->lastts);
1162         rtpheader[2] = htonl(rtp->ssrc); 
1163         data[12] = level;
1164         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1165                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1166                 if (res <0) 
1167                         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));
1168                 if(rtp_debug_test_addr(&rtp->them))
1169                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1170                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1171                    
1172         }
1173         return 0;
1174 }
1175
1176 #if defined(SOLARIS) && defined(__sparc__)
1177 static void put_uint32(unsigned char *buf, int i)
1178 {
1179         buf[0] = (i>>24) & 0xff;
1180         buf[1] = (i>>16) & 0xff;
1181         buf[2] = (i>>8)  & 0xff;
1182         buf[3] = i       & 0xff;
1183 }
1184 #else
1185 #define put_uint32(p,v) ((*((unsigned int *)(p))) = (v))
1186 #endif
1187
1188 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1189 {
1190         unsigned char *rtpheader;
1191         char iabuf[INET_ADDRSTRLEN];
1192         int hdrlen = 12;
1193         int res;
1194         int ms;
1195         int pred;
1196         int mark = 0;
1197
1198         ms = calc_txstamp(rtp, &f->delivery);
1199         /* Default prediction */
1200         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1201                 pred = rtp->lastts + ms * 8;
1202                 
1203                 switch(f->subclass) {
1204                 case AST_FORMAT_ULAW:
1205                 case AST_FORMAT_ALAW:
1206                         /* If we're within +/- 20ms from when where we
1207                            predict we should be, use that */
1208                         pred = rtp->lastts + f->datalen;
1209                         break;
1210                 case AST_FORMAT_ADPCM:
1211                 case AST_FORMAT_G726:
1212                         /* If we're within +/- 20ms from when where we
1213                            predict we should be, use that */
1214                         pred = rtp->lastts + f->datalen * 2;
1215                         break;
1216                 case AST_FORMAT_G729A:
1217                         pred = rtp->lastts + f->datalen * 8;
1218                         break;
1219                 case AST_FORMAT_GSM:
1220                         pred = rtp->lastts + (f->datalen * 160 / 33);
1221                         break;
1222                 case AST_FORMAT_ILBC:
1223                         pred = rtp->lastts + (f->datalen * 240 / 50);
1224                         break;
1225                 case AST_FORMAT_G723_1:
1226                         pred = rtp->lastts + g723_samples(f->data, f->datalen);
1227                         break;
1228                 case AST_FORMAT_SPEEX:
1229                     pred = rtp->lastts + 160;
1230                         /* assumes that the RTP packet contains one Speex frame */
1231                         break;
1232                 case AST_FORMAT_LPC10:
1233                         /* assumes that the RTP packet contains one LPC10 frame */
1234                         pred = rtp->lastts + 22 * 8;
1235                         pred += (((char *)(f->data))[7] & 0x1) * 8;
1236                         break;
1237                 default:
1238                         ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %s\n", ast_getformatname(f->subclass));
1239                 }
1240                 /* Re-calculate last TS */
1241                 rtp->lastts = rtp->lastts + ms * 8;
1242                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1243                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1244                            and if so, go with our prediction */
1245                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1246                                 rtp->lastts = pred;
1247                         else {
1248                                 if (option_debug > 2)
1249                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1250                                 mark = 1;
1251                         }
1252                 }
1253         } else {
1254                 mark = f->subclass & 0x1;
1255                 pred = rtp->lastovidtimestamp + f->samples;
1256                 /* Re-calculate last TS */
1257                 rtp->lastts = rtp->lastts + ms * 90;
1258                 /* If it's close to our prediction, go for it */
1259                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1260                         if (abs(rtp->lastts - pred) < 7200) {
1261                                 rtp->lastts = pred;
1262                                 rtp->lastovidtimestamp += f->samples;
1263                         } else {
1264                                 if (option_debug > 2)
1265                                         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);
1266                                 rtp->lastovidtimestamp = rtp->lastts;
1267                         }
1268                 }
1269         }
1270         /* Get a pointer to the header */
1271         rtpheader = (unsigned char *)(f->data - hdrlen);
1272
1273         put_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1274         put_uint32(rtpheader + 4, htonl(rtp->lastts));
1275         put_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
1276
1277         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1278                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1279                 if (res <0) 
1280                         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));
1281                 if(rtp_debug_test_addr(&rtp->them))
1282                         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1283                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1284         }
1285
1286         rtp->seqno++;
1287
1288         return 0;
1289 }
1290
1291 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1292 {
1293         struct ast_frame *f;
1294         int codec;
1295         int hdrlen = 12;
1296         int subclass;
1297         
1298
1299         /* If we have no peer, return immediately */    
1300         if (!rtp->them.sin_addr.s_addr)
1301                 return 0;
1302
1303         /* If there is no data length, return immediately */
1304         if (!_f->datalen) 
1305                 return 0;
1306         
1307         /* Make sure we have enough space for RTP header */
1308         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1309                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1310                 return -1;
1311         }
1312
1313         subclass = _f->subclass;
1314         if (_f->frametype == AST_FRAME_VIDEO)
1315                 subclass &= ~0x1;
1316
1317         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1318         if (codec < 0) {
1319                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1320                 return -1;
1321         }
1322
1323         if (rtp->lasttxformat != subclass) {
1324                 /* New format, reset the smoother */
1325                 if (option_debug)
1326                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1327                 rtp->lasttxformat = subclass;
1328                 if (rtp->smoother)
1329                         ast_smoother_free(rtp->smoother);
1330                 rtp->smoother = NULL;
1331         }
1332
1333
1334         switch(subclass) {
1335         case AST_FORMAT_ULAW:
1336         case AST_FORMAT_ALAW:
1337                 if (!rtp->smoother) {
1338                         rtp->smoother = ast_smoother_new(160);
1339                 }
1340                 if (!rtp->smoother) {
1341                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1342                         return -1;
1343                 }
1344                 ast_smoother_feed(rtp->smoother, _f);
1345                 
1346                 while((f = ast_smoother_read(rtp->smoother)))
1347                         ast_rtp_raw_write(rtp, f, codec);
1348                 break;
1349         case AST_FORMAT_ADPCM:
1350         case AST_FORMAT_G726:
1351                 if (!rtp->smoother) {
1352                         rtp->smoother = ast_smoother_new(80);
1353                 }
1354                 if (!rtp->smoother) {
1355                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1356                         return -1;
1357                 }
1358                 ast_smoother_feed(rtp->smoother, _f);
1359                 
1360                 while((f = ast_smoother_read(rtp->smoother)))
1361                         ast_rtp_raw_write(rtp, f, codec);
1362                 break;
1363         case AST_FORMAT_G729A:
1364                 if (!rtp->smoother) {
1365                         rtp->smoother = ast_smoother_new(20);
1366                         if (rtp->smoother)
1367                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1368                 }
1369                 if (!rtp->smoother) {
1370                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1371                         return -1;
1372                 }
1373                 ast_smoother_feed(rtp->smoother, _f);
1374                 
1375                 while((f = ast_smoother_read(rtp->smoother)))
1376                         ast_rtp_raw_write(rtp, f, codec);
1377                 break;
1378         case AST_FORMAT_GSM:
1379                 if (!rtp->smoother) {
1380                         rtp->smoother = ast_smoother_new(33);
1381                 }
1382                 if (!rtp->smoother) {
1383                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1384                         return -1;
1385                 }
1386                 ast_smoother_feed(rtp->smoother, _f);
1387                 while((f = ast_smoother_read(rtp->smoother)))
1388                         ast_rtp_raw_write(rtp, f, codec);
1389                 break;
1390         case AST_FORMAT_ILBC:
1391                 if (!rtp->smoother) {
1392                         rtp->smoother = ast_smoother_new(50);
1393                 }
1394                 if (!rtp->smoother) {
1395                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1396                         return -1;
1397                 }
1398                 ast_smoother_feed(rtp->smoother, _f);
1399                 while((f = ast_smoother_read(rtp->smoother)))
1400                         ast_rtp_raw_write(rtp, f, codec);
1401                 break;
1402         default:        
1403                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1404                 /* fall through to... */
1405         case AST_FORMAT_H261:
1406         case AST_FORMAT_H263:
1407         case AST_FORMAT_H263_PLUS:
1408         case AST_FORMAT_G723_1:
1409         case AST_FORMAT_LPC10:
1410         case AST_FORMAT_SPEEX:
1411                 /* Don't buffer outgoing frames; send them one-per-packet: */
1412                 if (_f->offset < hdrlen) {
1413                         f = ast_frdup(_f);
1414                 } else {
1415                         f = _f;
1416                 }
1417                 ast_rtp_raw_write(rtp, f, codec);
1418         }
1419                 
1420         return 0;
1421 }
1422
1423 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1424 {
1425         struct ast_rtp_protocol *cur, *prev;
1426
1427         cur = protos;
1428         prev = NULL;
1429         while(cur) {
1430                 if (cur == proto) {
1431                         if (prev)
1432                                 prev->next = proto->next;
1433                         else
1434                                 protos = proto->next;
1435                         return;
1436                 }
1437                 prev = cur;
1438                 cur = cur->next;
1439         }
1440 }
1441
1442 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1443 {
1444         struct ast_rtp_protocol *cur;
1445         cur = protos;
1446         while(cur) {
1447                 if (cur->type == proto->type) {
1448                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1449                         return -1;
1450                 }
1451                 cur = cur->next;
1452         }
1453         proto->next = protos;
1454         protos = proto;
1455         return 0;
1456 }
1457
1458 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1459 {
1460         struct ast_rtp_protocol *cur;
1461         cur = protos;
1462         while(cur) {
1463                 if (cur->type == chan->type) {
1464                         return cur;
1465                 }
1466                 cur = cur->next;
1467         }
1468         return NULL;
1469 }
1470
1471 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1472 {
1473         struct ast_frame *f;
1474         struct ast_channel *who, *cs[3];
1475         struct ast_rtp *p0, *p1;
1476         struct ast_rtp *vp0, *vp1;
1477         struct ast_rtp_protocol *pr0, *pr1;
1478         struct sockaddr_in ac0, ac1;
1479         struct sockaddr_in vac0, vac1;
1480         struct sockaddr_in t0, t1;
1481         struct sockaddr_in vt0, vt1;
1482         char iabuf[INET_ADDRSTRLEN];
1483         
1484         void *pvt0, *pvt1;
1485         int to;
1486         int codec0,codec1, oldcodec0, oldcodec1;
1487         
1488         memset(&vt0, 0, sizeof(vt0));
1489         memset(&vt1, 0, sizeof(vt1));
1490         memset(&vac0, 0, sizeof(vac0));
1491         memset(&vac1, 0, sizeof(vac1));
1492
1493         /* if need DTMF, cant native bridge */
1494         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1495                 return -2;
1496         ast_mutex_lock(&c0->lock);
1497         while(ast_mutex_trylock(&c1->lock)) {
1498                 ast_mutex_unlock(&c0->lock);
1499                 usleep(1);
1500                 ast_mutex_lock(&c0->lock);
1501         }
1502         pr0 = get_proto(c0);
1503         pr1 = get_proto(c1);
1504         if (!pr0) {
1505                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1506                 ast_mutex_unlock(&c0->lock);
1507                 ast_mutex_unlock(&c1->lock);
1508                 return -1;
1509         }
1510         if (!pr1) {
1511                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1512                 ast_mutex_unlock(&c0->lock);
1513                 ast_mutex_unlock(&c1->lock);
1514                 return -1;
1515         }
1516         pvt0 = c0->tech_pvt;
1517         pvt1 = c1->tech_pvt;
1518         p0 = pr0->get_rtp_info(c0);
1519         if (pr0->get_vrtp_info)
1520                 vp0 = pr0->get_vrtp_info(c0);
1521         else
1522                 vp0 = NULL;
1523         p1 = pr1->get_rtp_info(c1);
1524         if (pr1->get_vrtp_info)
1525                 vp1 = pr1->get_vrtp_info(c1);
1526         else
1527                 vp1 = NULL;
1528         if (!p0 || !p1) {
1529                 /* Somebody doesn't want to play... */
1530                 ast_mutex_unlock(&c0->lock);
1531                 ast_mutex_unlock(&c1->lock);
1532                 return -2;
1533         }
1534         if (pr0->get_codec)
1535                 codec0 = pr0->get_codec(c0);
1536         else
1537                 codec0 = 0;
1538         if (pr1->get_codec)
1539                 codec1 = pr1->get_codec(c1);
1540         else
1541                 codec1 = 0;
1542         if (pr0->get_codec && pr1->get_codec) {
1543                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1544                 if (!(codec0 & codec1)) {
1545                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1546                         ast_mutex_unlock(&c0->lock);
1547                         ast_mutex_unlock(&c1->lock);
1548                         return -2;
1549                 }
1550         }
1551         if (pr0->set_rtp_peer(c0, p1, vp1, codec1)) 
1552                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1553         else {
1554                 /* Store RTP peer */
1555                 ast_rtp_get_peer(p1, &ac1);
1556                 if (vp1)
1557                         ast_rtp_get_peer(vp1, &vac1);
1558         }
1559         if (pr1->set_rtp_peer(c1, p0, vp0, codec0))
1560                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1561         else {
1562                 /* Store RTP peer */
1563                 ast_rtp_get_peer(p0, &ac0);
1564                 if (vp0)
1565                         ast_rtp_get_peer(vp0, &vac0);
1566         }
1567         ast_mutex_unlock(&c0->lock);
1568         ast_mutex_unlock(&c1->lock);
1569         cs[0] = c0;
1570         cs[1] = c1;
1571         cs[2] = NULL;
1572         oldcodec0 = codec0;
1573         oldcodec1 = codec1;
1574         for (;;) {
1575                 if ((c0->tech_pvt != pvt0)  ||
1576                         (c1->tech_pvt != pvt1) ||
1577                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1578                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1579                                 if (c0->tech_pvt == pvt0) {
1580                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1581                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1582                                 }
1583                                 if (c1->tech_pvt == pvt1) {
1584                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1585                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1586                                 }
1587                                 /* Tell it to try again later */
1588                                 return -3;
1589                 }
1590                 to = -1;
1591                 ast_rtp_get_peer(p1, &t1);
1592                 ast_rtp_get_peer(p0, &t0);
1593                 if (pr0->get_codec)
1594                         codec0 = pr0->get_codec(c0);
1595                 if (pr1->get_codec)
1596                         codec1 = pr1->get_codec(c1);
1597                 if (vp1)
1598                         ast_rtp_get_peer(vp1, &vt1);
1599                 if (vp0)
1600                         ast_rtp_get_peer(vp0, &vt0);
1601                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
1602                         if (option_debug) {
1603                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1604                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
1605                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
1606                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
1607                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1608                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
1609                                 ast_log(LOG_DEBUG, "Oooh, '%s' wasv %s:%d/(format %d)\n", 
1610                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
1611                         }
1612                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1)) 
1613                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1614                         memcpy(&ac1, &t1, sizeof(ac1));
1615                         memcpy(&vac1, &vt1, sizeof(vac1));
1616                         oldcodec1 = codec1;
1617                 }
1618                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1619                         if (option_debug) {
1620                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1621                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
1622                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1623                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
1624                         }
1625                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0))
1626                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1627                         memcpy(&ac0, &t0, sizeof(ac0));
1628                         memcpy(&vac0, &vt0, sizeof(vac0));
1629                         oldcodec0 = codec0;
1630                 }
1631                 who = ast_waitfor_n(cs, 2, &to);
1632                 if (!who) {
1633                         if (option_debug)
1634                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1635                         /* check for hagnup / whentohangup */
1636                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1637                                 break;
1638                         continue;
1639                 }
1640                 f = ast_read(who);
1641                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1642                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1643                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1644                         *fo = f;
1645                         *rc = who;
1646                         if (option_debug)
1647                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1648                         if ((c0->tech_pvt == pvt0) && (!c0->_softhangup)) {
1649                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1650                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1651                         }
1652                         if ((c1->tech_pvt == pvt1) && (!c1->_softhangup)) {
1653                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1654                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1655                         }
1656                         /* That's all we needed */
1657                         return 0;
1658                 } else {
1659                         if ((f->frametype == AST_FRAME_DTMF) || 
1660                                 (f->frametype == AST_FRAME_VOICE) || 
1661                                 (f->frametype == AST_FRAME_VIDEO)) {
1662                                 /* Forward voice or DTMF frames if they happen upon us */
1663                                 if (who == c0) {
1664                                         ast_write(c1, f);
1665                                 } else if (who == c1) {
1666                                         ast_write(c0, f);
1667                                 }
1668                         }
1669                         ast_frfree(f);
1670                 }
1671                 /* Swap priority not that it's a big deal at this point */
1672                 cs[2] = cs[0];
1673                 cs[0] = cs[1];
1674                 cs[1] = cs[2];
1675                 
1676         }
1677         return -1;
1678 }
1679
1680 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
1681 {
1682         struct hostent *hp;
1683         struct ast_hostent ahp;
1684         char iabuf[INET_ADDRSTRLEN];
1685         int port = 0;
1686         char *p, *arg;
1687
1688         if (argc != 4)
1689                 return RESULT_SHOWUSAGE;
1690         arg = argv[3];
1691         p = strstr(arg, ":");
1692         if (p) {
1693                 *p = '\0';
1694                 p++;
1695                 port = atoi(p);
1696         }
1697         hp = ast_gethostbyname(arg, &ahp);
1698         if (hp == NULL)
1699                 return RESULT_SHOWUSAGE;
1700         rtpdebugaddr.sin_family = AF_INET;
1701         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
1702         rtpdebugaddr.sin_port = htons(port);
1703         if (port == 0)
1704                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
1705         else
1706                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
1707         rtpdebug = 1;
1708         return RESULT_SUCCESS;
1709 }
1710
1711 static int rtp_do_debug(int fd, int argc, char *argv[])
1712 {
1713         if(argc != 2){
1714                 if(argc != 4)
1715                         return RESULT_SHOWUSAGE;
1716                 return rtp_do_debug_ip(fd, argc, argv);
1717         }
1718         rtpdebug = 1;
1719         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
1720         ast_cli(fd, "RTP Debugging Enabled\n");
1721         return RESULT_SUCCESS;
1722 }
1723    
1724 static int rtp_no_debug(int fd, int argc, char *argv[])
1725 {
1726         if(argc !=3)
1727                 return RESULT_SHOWUSAGE;
1728         rtpdebug = 0;
1729         ast_cli(fd,"RTP Debugging Disabled\n");
1730         return RESULT_SUCCESS;
1731 }
1732
1733 static char debug_usage[] =
1734   "Usage: rtp debug [ip host[:port]]\n"
1735   "       Enable dumping of all RTP packets to and from host.\n";
1736
1737 static char no_debug_usage[] =
1738   "Usage: rtp no debug\n"
1739   "       Disable all RTP debugging\n";
1740
1741 static struct ast_cli_entry  cli_debug_ip =
1742 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
1743
1744 static struct ast_cli_entry  cli_debug =
1745 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
1746
1747 static struct ast_cli_entry  cli_no_debug =
1748 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
1749
1750 void ast_rtp_reload(void)
1751 {
1752         struct ast_config *cfg;
1753         char *s;
1754
1755         rtpstart = 5000;
1756         rtpend = 31000;
1757 #ifdef SO_NO_CHECK
1758         checksums = 1;
1759 #endif
1760         cfg = ast_config_load("rtp.conf");
1761         if (cfg) {
1762                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1763                         rtpstart = atoi(s);
1764                         if (rtpstart < 1024)
1765                                 rtpstart = 1024;
1766                         if (rtpstart > 65535)
1767                                 rtpstart = 65535;
1768                 }
1769                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1770                         rtpend = atoi(s);
1771                         if (rtpend < 1024)
1772                                 rtpend = 1024;
1773                         if (rtpend > 65535)
1774                                 rtpend = 65535;
1775                 }
1776                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
1777 #ifdef SO_NO_CHECK
1778                         if (ast_true(s))
1779                                 checksums = 1;
1780                         else
1781                                 checksums = 0;
1782 #else
1783                         if (ast_true(s))
1784                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
1785 #endif
1786                 }
1787                 ast_config_destroy(cfg);
1788         }
1789         if (rtpstart >= rtpend) {
1790                 ast_log(LOG_WARNING, "Unreasonable values for RTP start in rtp.conf/end\n");
1791                 rtpstart = 5000;
1792                 rtpend = 31000;
1793         }
1794         if (option_verbose > 1)
1795                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1796         
1797 }
1798
1799 void ast_rtp_init(void)
1800 {
1801         ast_cli_register(&cli_debug);
1802         ast_cli_register(&cli_debug_ip);
1803         ast_cli_register(&cli_no_debug);
1804         ast_rtp_reload();
1805 }