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