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