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