37fca3851bf8b132b6c8aec0f8bb657a4f4d83c8
[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         return 0;
1141 }
1142
1143 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1144 {
1145         unsigned int *rtpheader;
1146         int hdrlen = 12;
1147         int res;
1148         int payload;
1149         char data[256];
1150         char iabuf[INET_ADDRSTRLEN];
1151         level = 127 - (level & 0x7f);
1152         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1153
1154         /* If we have no peer, return immediately */    
1155         if (!rtp->them.sin_addr.s_addr)
1156                 return 0;
1157
1158         gettimeofday(&rtp->dtmfmute, NULL);
1159         rtp->dtmfmute.tv_usec += (500 * 1000);
1160         if (rtp->dtmfmute.tv_usec > 1000000) {
1161                 rtp->dtmfmute.tv_usec -= 1000000;
1162                 rtp->dtmfmute.tv_sec += 1;
1163         }
1164         
1165         /* Get a pointer to the header */
1166         rtpheader = (unsigned int *)data;
1167         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1168         rtpheader[1] = htonl(rtp->lastts);
1169         rtpheader[2] = htonl(rtp->ssrc); 
1170         data[12] = level;
1171         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1172                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1173                 if (res <0) 
1174                         ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1175                 if(rtp_debug_test_addr(&rtp->them))
1176                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1177                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);              
1178                    
1179         }
1180         return 0;
1181 }
1182
1183 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1184 {
1185         unsigned char *rtpheader;
1186         char iabuf[INET_ADDRSTRLEN];
1187         int hdrlen = 12;
1188         int res;
1189         int ms;
1190         int pred;
1191         int mark = 0;
1192
1193         ms = calc_txstamp(rtp, &f->delivery);
1194         /* Default prediction */
1195         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1196                 pred = rtp->lastts + ast_codec_get_samples(f);
1197
1198                 /* Re-calculate last TS */
1199                 rtp->lastts = rtp->lastts + ms * 8;
1200                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1201                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1202                            and if so, go with our prediction */
1203                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1204                                 rtp->lastts = pred;
1205                         else {
1206                                 if (option_debug > 2)
1207                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1208                                 mark = 1;
1209                         }
1210                 }
1211         } else {
1212                 mark = f->subclass & 0x1;
1213                 pred = rtp->lastovidtimestamp + f->samples;
1214                 /* Re-calculate last TS */
1215                 rtp->lastts = rtp->lastts + ms * 90;
1216                 /* If it's close to our prediction, go for it */
1217                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1218                         if (abs(rtp->lastts - pred) < 7200) {
1219                                 rtp->lastts = pred;
1220                                 rtp->lastovidtimestamp += f->samples;
1221                         } else {
1222                                 if (option_debug > 2)
1223                                         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);
1224                                 rtp->lastovidtimestamp = rtp->lastts;
1225                         }
1226                 }
1227         }
1228         /* If the timestamp for non-digit packets has moved beyond the timestamp
1229            for digits, update the digit timestamp.
1230         */
1231         if (rtp->lastts > rtp->lastdigitts)
1232                 rtp->lastdigitts = rtp->lastts;
1233
1234         /* Get a pointer to the header */
1235         rtpheader = (unsigned char *)(f->data - hdrlen);
1236
1237         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1238         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1239         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
1240
1241         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1242                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1243                 if (res <0) 
1244                         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));
1245                 if(rtp_debug_test_addr(&rtp->them))
1246                         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1247                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1248         }
1249
1250         rtp->seqno++;
1251
1252         return 0;
1253 }
1254
1255 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1256 {
1257         struct ast_frame *f;
1258         int codec;
1259         int hdrlen = 12;
1260         int subclass;
1261         
1262
1263         /* If we have no peer, return immediately */    
1264         if (!rtp->them.sin_addr.s_addr)
1265                 return 0;
1266
1267         /* If there is no data length, return immediately */
1268         if (!_f->datalen) 
1269                 return 0;
1270         
1271         /* Make sure we have enough space for RTP header */
1272         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1273                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1274                 return -1;
1275         }
1276
1277         subclass = _f->subclass;
1278         if (_f->frametype == AST_FRAME_VIDEO)
1279                 subclass &= ~0x1;
1280
1281         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1282         if (codec < 0) {
1283                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1284                 return -1;
1285         }
1286
1287         if (rtp->lasttxformat != subclass) {
1288                 /* New format, reset the smoother */
1289                 if (option_debug)
1290                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1291                 rtp->lasttxformat = subclass;
1292                 if (rtp->smoother)
1293                         ast_smoother_free(rtp->smoother);
1294                 rtp->smoother = NULL;
1295         }
1296
1297
1298         switch(subclass) {
1299         case AST_FORMAT_SLINEAR:
1300                 if (!rtp->smoother) {
1301                         rtp->smoother = ast_smoother_new(320);
1302                 }
1303                 if (!rtp->smoother) {
1304                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1305                         return -1;
1306                 }
1307                 ast_smoother_feed_be(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_ULAW:
1313         case AST_FORMAT_ALAW:
1314                 if (!rtp->smoother) {
1315                         rtp->smoother = ast_smoother_new(160);
1316                 }
1317                 if (!rtp->smoother) {
1318                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1319                         return -1;
1320                 }
1321                 ast_smoother_feed(rtp->smoother, _f);
1322                 
1323                 while((f = ast_smoother_read(rtp->smoother)))
1324                         ast_rtp_raw_write(rtp, f, codec);
1325                 break;
1326         case AST_FORMAT_ADPCM:
1327         case AST_FORMAT_G726:
1328                 if (!rtp->smoother) {
1329                         rtp->smoother = ast_smoother_new(80);
1330                 }
1331                 if (!rtp->smoother) {
1332                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1333                         return -1;
1334                 }
1335                 ast_smoother_feed(rtp->smoother, _f);
1336                 
1337                 while((f = ast_smoother_read(rtp->smoother)))
1338                         ast_rtp_raw_write(rtp, f, codec);
1339                 break;
1340         case AST_FORMAT_G729A:
1341                 if (!rtp->smoother) {
1342                         rtp->smoother = ast_smoother_new(20);
1343                         if (rtp->smoother)
1344                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1345                 }
1346                 if (!rtp->smoother) {
1347                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1348                         return -1;
1349                 }
1350                 ast_smoother_feed(rtp->smoother, _f);
1351                 
1352                 while((f = ast_smoother_read(rtp->smoother)))
1353                         ast_rtp_raw_write(rtp, f, codec);
1354                 break;
1355         case AST_FORMAT_GSM:
1356                 if (!rtp->smoother) {
1357                         rtp->smoother = ast_smoother_new(33);
1358                 }
1359                 if (!rtp->smoother) {
1360                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1361                         return -1;
1362                 }
1363                 ast_smoother_feed(rtp->smoother, _f);
1364                 while((f = ast_smoother_read(rtp->smoother)))
1365                         ast_rtp_raw_write(rtp, f, codec);
1366                 break;
1367         case AST_FORMAT_ILBC:
1368                 if (!rtp->smoother) {
1369                         rtp->smoother = ast_smoother_new(50);
1370                 }
1371                 if (!rtp->smoother) {
1372                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1373                         return -1;
1374                 }
1375                 ast_smoother_feed(rtp->smoother, _f);
1376                 while((f = ast_smoother_read(rtp->smoother)))
1377                         ast_rtp_raw_write(rtp, f, codec);
1378                 break;
1379         default:        
1380                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1381                 /* fall through to... */
1382         case AST_FORMAT_H261:
1383         case AST_FORMAT_H263:
1384         case AST_FORMAT_H263_PLUS:
1385         case AST_FORMAT_G723_1:
1386         case AST_FORMAT_LPC10:
1387         case AST_FORMAT_SPEEX:
1388                 /* Don't buffer outgoing frames; send them one-per-packet: */
1389                 if (_f->offset < hdrlen) {
1390                         f = ast_frdup(_f);
1391                 } else {
1392                         f = _f;
1393                 }
1394                 ast_rtp_raw_write(rtp, f, codec);
1395         }
1396                 
1397         return 0;
1398 }
1399
1400 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1401 {
1402         struct ast_rtp_protocol *cur, *prev;
1403
1404         cur = protos;
1405         prev = NULL;
1406         while(cur) {
1407                 if (cur == proto) {
1408                         if (prev)
1409                                 prev->next = proto->next;
1410                         else
1411                                 protos = proto->next;
1412                         return;
1413                 }
1414                 prev = cur;
1415                 cur = cur->next;
1416         }
1417 }
1418
1419 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1420 {
1421         struct ast_rtp_protocol *cur;
1422         cur = protos;
1423         while(cur) {
1424                 if (cur->type == proto->type) {
1425                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1426                         return -1;
1427                 }
1428                 cur = cur->next;
1429         }
1430         proto->next = protos;
1431         protos = proto;
1432         return 0;
1433 }
1434
1435 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1436 {
1437         struct ast_rtp_protocol *cur;
1438         cur = protos;
1439         while(cur) {
1440                 if (cur->type == chan->type) {
1441                         return cur;
1442                 }
1443                 cur = cur->next;
1444         }
1445         return NULL;
1446 }
1447
1448 /* ast_rtp_bridge: Bridge calls. If possible and allowed, initiate
1449         re-invite so the peers exchange media directly outside 
1450         of Asterisk. */
1451 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1452 {
1453         struct ast_frame *f;
1454         struct ast_channel *who, *cs[3];
1455         struct ast_rtp *p0, *p1;
1456         struct ast_rtp *vp0, *vp1;
1457         struct ast_rtp_protocol *pr0, *pr1;
1458         struct sockaddr_in ac0, ac1;
1459         struct sockaddr_in vac0, vac1;
1460         struct sockaddr_in t0, t1;
1461         struct sockaddr_in vt0, vt1;
1462         char iabuf[INET_ADDRSTRLEN];
1463         
1464         void *pvt0, *pvt1;
1465         int to;
1466         int codec0,codec1, oldcodec0, oldcodec1;
1467         
1468         memset(&vt0, 0, sizeof(vt0));
1469         memset(&vt1, 0, sizeof(vt1));
1470         memset(&vac0, 0, sizeof(vac0));
1471         memset(&vac1, 0, sizeof(vac1));
1472
1473         /* if need DTMF, cant native bridge */
1474         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1475                 return -2;
1476         ast_mutex_lock(&c0->lock);
1477         while(ast_mutex_trylock(&c1->lock)) {
1478                 ast_mutex_unlock(&c0->lock);
1479                 usleep(1);
1480                 ast_mutex_lock(&c0->lock);
1481         }
1482         pr0 = get_proto(c0);
1483         pr1 = get_proto(c1);
1484         if (!pr0) {
1485                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1486                 ast_mutex_unlock(&c0->lock);
1487                 ast_mutex_unlock(&c1->lock);
1488                 return -1;
1489         }
1490         if (!pr1) {
1491                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1492                 ast_mutex_unlock(&c0->lock);
1493                 ast_mutex_unlock(&c1->lock);
1494                 return -1;
1495         }
1496         pvt0 = c0->tech_pvt;
1497         pvt1 = c1->tech_pvt;
1498         p0 = pr0->get_rtp_info(c0);
1499         if (pr0->get_vrtp_info)
1500                 vp0 = pr0->get_vrtp_info(c0);
1501         else
1502                 vp0 = NULL;
1503         p1 = pr1->get_rtp_info(c1);
1504         if (pr1->get_vrtp_info)
1505                 vp1 = pr1->get_vrtp_info(c1);
1506         else
1507                 vp1 = NULL;
1508         if (!p0 || !p1) {
1509                 /* Somebody doesn't want to play... */
1510                 ast_mutex_unlock(&c0->lock);
1511                 ast_mutex_unlock(&c1->lock);
1512                 return -2;
1513         }
1514         if (pr0->get_codec)
1515                 codec0 = pr0->get_codec(c0);
1516         else
1517                 codec0 = 0;
1518         if (pr1->get_codec)
1519                 codec1 = pr1->get_codec(c1);
1520         else
1521                 codec1 = 0;
1522         if (pr0->get_codec && pr1->get_codec) {
1523                 /* Hey, we can't do reinvite if both parties speak different codecs */
1524                 if (!(codec0 & codec1)) {
1525                         if (option_debug)
1526                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
1527                         ast_mutex_unlock(&c0->lock);
1528                         ast_mutex_unlock(&c1->lock);
1529                         return -2;
1530                 }
1531         }
1532         /* Ok, we should be able to redirect the media. Start with one channel */
1533         if (pr0->set_rtp_peer(c0, p1, vp1, codec1)) 
1534                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1535         else {
1536                 /* Store RTP peer */
1537                 ast_rtp_get_peer(p1, &ac1);
1538                 if (vp1)
1539                         ast_rtp_get_peer(vp1, &vac1);
1540         }
1541         /* Then test the other channel */
1542         if (pr1->set_rtp_peer(c1, p0, vp0, codec0))
1543                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1544         else {
1545                 /* Store RTP peer */
1546                 ast_rtp_get_peer(p0, &ac0);
1547                 if (vp0)
1548                         ast_rtp_get_peer(vp0, &vac0);
1549         }
1550         ast_mutex_unlock(&c0->lock);
1551         ast_mutex_unlock(&c1->lock);
1552         cs[0] = c0;
1553         cs[1] = c1;
1554         cs[2] = NULL;
1555         oldcodec0 = codec0;
1556         oldcodec1 = codec1;
1557         for (;;) {
1558                 if ((c0->tech_pvt != pvt0)  ||
1559                         (c1->tech_pvt != pvt1) ||
1560                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1561                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1562                                 if (c0->tech_pvt == pvt0) {
1563                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1564                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1565                                 }
1566                                 if (c1->tech_pvt == pvt1) {
1567                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1568                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1569                                 }
1570                                 /* Tell it to try again later */
1571                                 return -3;
1572                 }
1573                 to = -1;
1574                 ast_rtp_get_peer(p1, &t1);
1575                 ast_rtp_get_peer(p0, &t0);
1576                 if (pr0->get_codec)
1577                         codec0 = pr0->get_codec(c0);
1578                 if (pr1->get_codec)
1579                         codec1 = pr1->get_codec(c1);
1580                 if (vp1)
1581                         ast_rtp_get_peer(vp1, &vt1);
1582                 if (vp0)
1583                         ast_rtp_get_peer(vp0, &vt0);
1584                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
1585                         if (option_debug) {
1586                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1587                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
1588                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n", 
1589                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
1590                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1591                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
1592                                 ast_log(LOG_DEBUG, "Oooh, '%s' wasv %s:%d/(format %d)\n", 
1593                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
1594                         }
1595                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1)) 
1596                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1597                         memcpy(&ac1, &t1, sizeof(ac1));
1598                         memcpy(&vac1, &vt1, sizeof(vac1));
1599                         oldcodec1 = codec1;
1600                 }
1601                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1602                         if (option_debug) {
1603                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n", 
1604                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
1605                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n", 
1606                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
1607                         }
1608                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0))
1609                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1610                         memcpy(&ac0, &t0, sizeof(ac0));
1611                         memcpy(&vac0, &vt0, sizeof(vac0));
1612                         oldcodec0 = codec0;
1613                 }
1614                 who = ast_waitfor_n(cs, 2, &to);
1615                 if (!who) {
1616                         if (option_debug)
1617                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1618                         /* check for hangup / whentohangup */
1619                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1620                                 break;
1621                         continue;
1622                 }
1623                 f = ast_read(who);
1624                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1625                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1626                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1627                         *fo = f;
1628                         *rc = who;
1629                         if (option_debug)
1630                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1631                         if ((c0->tech_pvt == pvt0) && (!c0->_softhangup)) {
1632                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0)) 
1633                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1634                         }
1635                         if ((c1->tech_pvt == pvt1) && (!c1->_softhangup)) {
1636                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0)) 
1637                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1638                         }
1639                         /* That's all we needed */
1640                         return 0;
1641                 } else {
1642                         if ((f->frametype == AST_FRAME_DTMF) || 
1643                                 (f->frametype == AST_FRAME_VOICE) || 
1644                                 (f->frametype == AST_FRAME_VIDEO)) {
1645                                 /* Forward voice or DTMF frames if they happen upon us */
1646                                 if (who == c0) {
1647                                         ast_write(c1, f);
1648                                 } else if (who == c1) {
1649                                         ast_write(c0, f);
1650                                 }
1651                         }
1652                         ast_frfree(f);
1653                 }
1654                 /* Swap priority not that it's a big deal at this point */
1655                 cs[2] = cs[0];
1656                 cs[0] = cs[1];
1657                 cs[1] = cs[2];
1658                 
1659         }
1660         return -1;
1661 }
1662
1663 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
1664 {
1665         struct hostent *hp;
1666         struct ast_hostent ahp;
1667         char iabuf[INET_ADDRSTRLEN];
1668         int port = 0;
1669         char *p, *arg;
1670
1671         if (argc != 4)
1672                 return RESULT_SHOWUSAGE;
1673         arg = argv[3];
1674         p = strstr(arg, ":");
1675         if (p) {
1676                 *p = '\0';
1677                 p++;
1678                 port = atoi(p);
1679         }
1680         hp = ast_gethostbyname(arg, &ahp);
1681         if (hp == NULL)
1682                 return RESULT_SHOWUSAGE;
1683         rtpdebugaddr.sin_family = AF_INET;
1684         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
1685         rtpdebugaddr.sin_port = htons(port);
1686         if (port == 0)
1687                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
1688         else
1689                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
1690         rtpdebug = 1;
1691         return RESULT_SUCCESS;
1692 }
1693
1694 static int rtp_do_debug(int fd, int argc, char *argv[])
1695 {
1696         if(argc != 2){
1697                 if(argc != 4)
1698                         return RESULT_SHOWUSAGE;
1699                 return rtp_do_debug_ip(fd, argc, argv);
1700         }
1701         rtpdebug = 1;
1702         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
1703         ast_cli(fd, "RTP Debugging Enabled\n");
1704         return RESULT_SUCCESS;
1705 }
1706    
1707 static int rtp_no_debug(int fd, int argc, char *argv[])
1708 {
1709         if(argc !=3)
1710                 return RESULT_SHOWUSAGE;
1711         rtpdebug = 0;
1712         ast_cli(fd,"RTP Debugging Disabled\n");
1713         return RESULT_SUCCESS;
1714 }
1715
1716 static char debug_usage[] =
1717   "Usage: rtp debug [ip host[:port]]\n"
1718   "       Enable dumping of all RTP packets to and from host.\n";
1719
1720 static char no_debug_usage[] =
1721   "Usage: rtp no debug\n"
1722   "       Disable all RTP debugging\n";
1723
1724 static struct ast_cli_entry  cli_debug_ip =
1725 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
1726
1727 static struct ast_cli_entry  cli_debug =
1728 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
1729
1730 static struct ast_cli_entry  cli_no_debug =
1731 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
1732
1733 void ast_rtp_reload(void)
1734 {
1735         struct ast_config *cfg;
1736         char *s;
1737
1738         rtpstart = 5000;
1739         rtpend = 31000;
1740         cfg = ast_config_load("rtp.conf");
1741         if (cfg) {
1742                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1743                         rtpstart = atoi(s);
1744                         if (rtpstart < 1024)
1745                                 rtpstart = 1024;
1746                         if (rtpstart > 65535)
1747                                 rtpstart = 65535;
1748                 }
1749                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1750                         rtpend = atoi(s);
1751                         if (rtpend < 1024)
1752                                 rtpend = 1024;
1753                         if (rtpend > 65535)
1754                                 rtpend = 65535;
1755                 }
1756                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
1757 #ifdef SO_NO_CHECK
1758                         if (ast_false(s))
1759                                 nochecksums = 1;
1760                         else
1761                                 nochecksums = 0;
1762 #else
1763                         if (ast_false(s))
1764                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
1765 #endif
1766                 }
1767                 ast_config_destroy(cfg);
1768         }
1769         if (rtpstart >= rtpend) {
1770                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
1771                 rtpstart = 5000;
1772                 rtpend = 31000;
1773         }
1774         if (option_verbose > 1)
1775                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1776         
1777 }
1778
1779 void ast_rtp_init(void)
1780 {
1781         ast_cli_register(&cli_debug);
1782         ast_cli_register(&cli_debug_ip);
1783         ast_cli_register(&cli_no_debug);
1784         ast_rtp_reload();
1785 }