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