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