Same for transmit core
[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         if (rtp->nat) {
417                 /* Send to whoever sent to us */
418                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
419                     (rtp->them.sin_port != sin.sin_port)) {
420                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
421                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
422                 }
423         }
424         /* Ignore if the other side hasn't been given an address
425            yet.  */
426         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
427                 return &null_frame;
428
429         /* Get fields */
430         seqno = ntohl(rtpheader[0]);
431         payloadtype = (seqno & 0x7f0000) >> 16;
432         mark = seqno & (1 << 23);
433         seqno &= 0xffff;
434         timestamp = ntohl(rtpheader[1]);
435
436 #if 0
437         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);
438 #endif  
439         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
440         if (!rtpPT.isAstFormat) {
441           // This is special in-band data that's not one of our codecs
442           if (rtpPT.code == AST_RTP_DTMF) {
443             /* It's special -- rfc2833 process it */
444             f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
445             if (f) return f; else return &null_frame;
446           } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
447             /* It's really special -- process it the Cisco way */
448             f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
449             if (f) return f; else return &null_frame;
450           } else if (rtpPT.code == AST_RTP_CN) {
451             /* Comfort Noise */
452             f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
453             if (f) return f; else return &null_frame;
454           } else {
455             ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
456             return &null_frame;
457           }
458         }
459         rtp->f.subclass = rtpPT.code;
460         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO)
461                 rtp->f.frametype = AST_FRAME_VOICE;
462         else
463                 rtp->f.frametype = AST_FRAME_VIDEO;
464         rtp->lastrxformat = rtp->f.subclass;
465
466         if (!rtp->lastrxts)
467                 rtp->lastrxts = timestamp;
468
469         if (rtp->dtmfcount) {
470 #if 0
471                 printf("dtmfcount was %d\n", rtp->dtmfcount);
472 #endif          
473                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
474                 if (rtp->dtmfcount < 0)
475                         rtp->dtmfcount = 0;
476 #if 0
477                 if (dtmftimeout != rtp->dtmfcount)
478                         printf("dtmfcount is %d\n", rtp->dtmfcount);
479 #endif
480         }
481         rtp->lastrxts = timestamp;
482
483         /* Send any pending DTMF */
484         if (rtp->resp && !rtp->dtmfcount) {
485                 ast_log(LOG_DEBUG, "Sending pending DTMF\n");
486                 return send_dtmf(rtp);
487         }
488         rtp->f.mallocd = 0;
489         rtp->f.datalen = res - hdrlen;
490         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
491         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
492         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
493                 switch(rtp->f.subclass) {
494                 case AST_FORMAT_ULAW:
495                 case AST_FORMAT_ALAW:
496                         rtp->f.samples = rtp->f.datalen;
497                         break;
498                 case AST_FORMAT_SLINEAR:
499                         rtp->f.samples = rtp->f.datalen / 2;
500                         break;
501                 case AST_FORMAT_GSM:
502                         rtp->f.samples = 160 * (rtp->f.datalen / 33);
503                         break;
504                 case AST_FORMAT_ILBC:
505                         rtp->f.samples = 240 * (rtp->f.datalen / 50);
506                         break;
507                 case AST_FORMAT_ADPCM:
508                 case AST_FORMAT_G726:
509                         rtp->f.samples = rtp->f.datalen * 2;
510                         break;
511                 case AST_FORMAT_G729A:
512                         rtp->f.samples = rtp->f.datalen * 8;
513                         break;
514                 case AST_FORMAT_G723_1:
515                         rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
516                         break;
517                 case AST_FORMAT_SPEEX:
518                         rtp->f.samples = 160;
519                         // assumes that the RTP packet contained one Speex frame
520                         break;
521                 default:
522                         ast_log(LOG_NOTICE, "Unable to calculate samples for format %s\n", ast_getformatname(rtp->f.subclass));
523                         break;
524                 }
525                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp);
526         } else {
527                 /* Video -- samples is # of samples vs. 90000 */
528                 if (!rtp->lastividtimestamp)
529                         rtp->lastividtimestamp = timestamp;
530                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
531                 rtp->lastividtimestamp = timestamp;
532                 if (mark)
533                         rtp->f.subclass |= 0x1;
534                 
535         }
536         rtp->f.src = "RTP";
537         return &rtp->f;
538 }
539
540 // The following array defines the MIME type (and subtype) for each
541 // of our codecs, or RTP-specific data type.
542 static struct {
543   struct rtpPayloadType payloadType;
544   char* type;
545   char* subtype;
546 } mimeTypes[] = {
547   {{1, AST_FORMAT_G723_1}, "audio", "G723"},
548   {{1, AST_FORMAT_GSM}, "audio", "GSM"},
549   {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
550   {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
551   {{1, AST_FORMAT_G726}, "audio", "G726-32"},
552   {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
553   {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
554   {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
555   {{1, AST_FORMAT_G729A}, "audio", "G729"},
556   {{1, AST_FORMAT_SPEEX}, "audio", "SPEEX"},
557   {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
558   {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
559   {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
560   {{0, AST_RTP_CN}, "audio", "CN"},
561   {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
562   {{1, AST_FORMAT_PNG}, "video", "PNG"},
563   {{1, AST_FORMAT_H261}, "video", "H261"},
564   {{1, AST_FORMAT_H263}, "video", "H263"},
565 };
566
567 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
568    also, our own choices for dynamic payload types.  This is our master
569    table for transmission */
570 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
571   [0] = {1, AST_FORMAT_ULAW},
572   [2] = {1, AST_FORMAT_G726}, // Technically this is G.721, but if Cisco can do it, so can we...
573   [3] = {1, AST_FORMAT_GSM},
574   [4] = {1, AST_FORMAT_G723_1},
575   [5] = {1, AST_FORMAT_ADPCM}, // 8 kHz
576   [6] = {1, AST_FORMAT_ADPCM}, // 16 kHz
577   [7] = {1, AST_FORMAT_LPC10},
578   [8] = {1, AST_FORMAT_ALAW},
579   [10] = {1, AST_FORMAT_SLINEAR}, // 2 channels
580   [11] = {1, AST_FORMAT_SLINEAR}, // 1 channel
581   [13] = {0, AST_RTP_CN},
582   [16] = {1, AST_FORMAT_ADPCM}, // 11.025 kHz
583   [17] = {1, AST_FORMAT_ADPCM}, // 22.050 kHz
584   [18] = {1, AST_FORMAT_G729A},
585   [26] = {1, AST_FORMAT_JPEG},
586   [31] = {1, AST_FORMAT_H261},
587   [34] = {1, AST_FORMAT_H263},
588   [97] = {1, AST_FORMAT_ILBC},
589   [101] = {0, AST_RTP_DTMF},
590   [110] = {1, AST_FORMAT_SPEEX},
591   [121] = {0, AST_RTP_CISCO_DTMF}, // Must be type 121
592 };
593
594 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
595 {
596   int i;
597
598   for (i = 0; i < MAX_RTP_PT; ++i) {
599     rtp->current_RTP_PT[i].isAstFormat = 0;
600     rtp->current_RTP_PT[i].code = 0;
601   }
602
603   rtp->rtp_lookup_code_cache_isAstFormat = 0;
604   rtp->rtp_lookup_code_cache_code = 0;
605   rtp->rtp_lookup_code_cache_result = 0;
606 }
607
608 void ast_rtp_pt_default(struct ast_rtp* rtp) 
609 {
610   int i;
611   /* Initialize to default payload types */
612   for (i = 0; i < MAX_RTP_PT; ++i) {
613     rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
614     rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
615   }
616
617   rtp->rtp_lookup_code_cache_isAstFormat = 0;
618   rtp->rtp_lookup_code_cache_code = 0;
619   rtp->rtp_lookup_code_cache_result = 0;
620 }
621
622 // Make a note of a RTP payload type that was seen in a SDP "m=" line.
623 // By default, use the well-known value for this type (although it may
624 // still be set to a different value by a subsequent "a=rtpmap:" line):
625 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) {
626   if (pt < 0 || pt > MAX_RTP_PT) return; // bogus payload type
627
628   if (static_RTP_PT[pt].code != 0) {
629     rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
630   }
631
632
633 // Make a note of a RTP payload type (with MIME type) that was seen in
634 // a SDP "a=rtpmap:" line.
635 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
636                          char* mimeType, char* mimeSubtype) {
637   int i;
638
639   if (pt < 0 || pt > MAX_RTP_PT) return; // bogus payload type
640
641   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
642     if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
643         strcasecmp(mimeType, mimeTypes[i].type) == 0) {
644       rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
645       return;
646     }
647   }
648
649
650 // Return the union of all of the codecs that were set by rtp_set...() calls
651 // They're returned as two distinct sets: AST_FORMATs, and AST_RTPs
652 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
653                              int* astFormats, int* nonAstFormats) {
654   int pt;
655
656   *astFormats = *nonAstFormats = 0;
657   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
658     if (rtp->current_RTP_PT[pt].isAstFormat) {
659       *astFormats |= rtp->current_RTP_PT[pt].code;
660     } else {
661       *nonAstFormats |= rtp->current_RTP_PT[pt].code;
662     }
663   }
664 }
665
666 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) {
667   if (pt < 0 || pt > MAX_RTP_PT) {
668     struct rtpPayloadType result;
669     result.isAstFormat = result.code = 0;
670     return result; // bogus payload type
671   }
672   /* Gotta use our static one, since that's what we sent against */
673   return static_RTP_PT[pt];
674 }
675
676 int ast_rtp_lookup_code(struct ast_rtp* rtp, int isAstFormat, int code) {
677   int pt;
678
679   /* Looks up an RTP code out of our *static* outbound list */
680
681   if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
682       code == rtp->rtp_lookup_code_cache_code) {
683     // Use our cached mapping, to avoid the overhead of the loop below
684     return rtp->rtp_lookup_code_cache_result;
685   }
686
687   for (pt = 0; pt < MAX_RTP_PT; ++pt) {
688     if (static_RTP_PT[pt].code == code &&
689                 static_RTP_PT[pt].isAstFormat == isAstFormat) {
690       rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
691       rtp->rtp_lookup_code_cache_code = code;
692       rtp->rtp_lookup_code_cache_result = pt;
693       return pt;
694     }
695   }
696   return -1;
697 }
698
699 char* ast_rtp_lookup_mime_subtype(int isAstFormat, int code) {
700   int i;
701
702   for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
703     if (mimeTypes[i].payloadType.code == code &&
704         mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
705       return mimeTypes[i].subtype;
706     }
707   }
708   return "";
709 }
710
711 static struct ast_rtcp *ast_rtcp_new(void)
712 {
713         struct ast_rtcp *rtcp;
714         long flags;
715         rtcp = malloc(sizeof(struct ast_rtcp));
716         if (!rtcp)
717                 return NULL;
718         memset(rtcp, 0, sizeof(struct ast_rtcp));
719         rtcp->s = socket(AF_INET, SOCK_DGRAM, 0);
720         rtcp->us.sin_family = AF_INET;
721         if (rtcp->s < 0) {
722                 free(rtcp);
723                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
724                 return NULL;
725         }
726         flags = fcntl(rtcp->s, F_GETFL);
727         fcntl(rtcp->s, F_SETFL, flags | O_NONBLOCK);
728         return rtcp;
729 }
730
731 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
732 {
733         struct ast_rtp *rtp;
734         int x;
735         int flags;
736         int startplace;
737         rtp = malloc(sizeof(struct ast_rtp));
738         if (!rtp)
739                 return NULL;
740         memset(rtp, 0, sizeof(struct ast_rtp));
741         rtp->them.sin_family = AF_INET;
742         rtp->us.sin_family = AF_INET;
743         rtp->s = socket(AF_INET, SOCK_DGRAM, 0);
744         rtp->ssrc = rand();
745         rtp->seqno = rand() & 0xffff;
746         if (rtp->s < 0) {
747                 free(rtp);
748                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
749                 return NULL;
750         }
751         if (sched && rtcpenable) {
752                 rtp->sched = sched;
753                 rtp->rtcp = ast_rtcp_new();
754         }
755         flags = fcntl(rtp->s, F_GETFL);
756         fcntl(rtp->s, F_SETFL, flags | O_NONBLOCK);
757         /* Find us a place */
758         x = (rand() % (rtpend-rtpstart)) + rtpstart;
759         x = x & ~1;
760         startplace = x;
761         for (;;) {
762                 /* Must be an even port number by RTP spec */
763                 rtp->us.sin_port = htons(x);
764                 if (rtp->rtcp)
765                         rtp->rtcp->us.sin_port = htons(x + 1);
766                 if (!bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us)) &&
767                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
768                         break;
769                 if (errno != EADDRINUSE) {
770                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
771                         close(rtp->s);
772                         if (rtp->rtcp) {
773                                 close(rtp->rtcp->s);
774                                 free(rtp->rtcp);
775                         }
776                         free(rtp);
777                         return NULL;
778                 }
779                 x += 2;
780                 if (x > rtpend)
781                         x = (rtpstart + 1) & ~1;
782                 if (x == startplace) {
783                         ast_log(LOG_WARNING, "No RTP ports remaining\n");
784                         close(rtp->s);
785                         if (rtp->rtcp) {
786                                 close(rtp->rtcp->s);
787                                 free(rtp->rtcp);
788                         }
789                         free(rtp);
790                         return NULL;
791                 }
792         }
793         if (io && sched && callbackmode) {
794                 /* Operate this one in a callback mode */
795                 rtp->sched = sched;
796                 rtp->io = io;
797                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
798         }
799         ast_rtp_pt_default(rtp);
800         return rtp;
801 }
802
803 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
804 {
805         int res;
806         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
807                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
808         return res;
809 }
810
811 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
812 {
813         rtp->them.sin_port = them->sin_port;
814         rtp->them.sin_addr = them->sin_addr;
815         if (rtp->rtcp) {
816                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
817                 rtp->rtcp->them.sin_addr = them->sin_addr;
818         }
819 }
820
821 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
822 {
823         them->sin_family = AF_INET;
824         them->sin_port = rtp->them.sin_port;
825         them->sin_addr = rtp->them.sin_addr;
826 }
827
828 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
829 {
830         memcpy(us, &rtp->us, sizeof(rtp->us));
831 }
832
833 void ast_rtp_stop(struct ast_rtp *rtp)
834 {
835         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
836         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
837         if (rtp->rtcp) {
838                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
839                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
840         }
841 }
842
843 void ast_rtp_destroy(struct ast_rtp *rtp)
844 {
845         if (rtp->smoother)
846                 ast_smoother_free(rtp->smoother);
847         if (rtp->ioid)
848                 ast_io_remove(rtp->io, rtp->ioid);
849         if (rtp->s > -1)
850                 close(rtp->s);
851         if (rtp->rtcp) {
852                 close(rtp->rtcp->s);
853                 free(rtp->rtcp);
854         }
855         free(rtp);
856 }
857
858 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
859 {
860         struct timeval now;
861         unsigned int ms;
862         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
863                 gettimeofday(&rtp->txcore, NULL);
864                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
865         }
866         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
867                 /* Use previous txcore */
868                 ms = (delivery->tv_sec - rtp->txcore.tv_sec) * 1000;
869                 ms += (delivery->tv_usec - rtp->txcore.tv_usec) / 1000;
870                 rtp->txcore.tv_sec = delivery->tv_sec;
871                 rtp->txcore.tv_usec = delivery->tv_usec;
872         } else {
873                 gettimeofday(&now, NULL);
874                 ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
875                 ms += (now.tv_usec - rtp->txcore.tv_usec) / 1000;
876                 /* Use what we just got for next time */
877                 rtp->txcore.tv_sec = now.tv_sec;
878                 rtp->txcore.tv_usec = now.tv_usec;
879         }
880         return ms;
881 }
882
883 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
884 {
885         unsigned int *rtpheader;
886         int hdrlen = 12;
887         int res;
888         int ms;
889         int pred;
890         int x;
891         char data[256];
892
893         if ((digit <= '9') && (digit >= '0'))
894                 digit -= '0';
895         else if (digit == '*')
896                 digit = 10;
897         else if (digit == '#')
898                 digit = 11;
899         else if ((digit >= 'A') && (digit <= 'D')) 
900                 digit = digit - 'A' + 12;
901         else if ((digit >= 'a') && (digit <= 'd')) 
902                 digit = digit - 'a' + 12;
903         else {
904                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
905                 return -1;
906         }
907         
908
909         /* If we have no peer, return immediately */    
910         if (!rtp->them.sin_addr.s_addr)
911                 return 0;
912
913         gettimeofday(&rtp->dtmfmute, NULL);
914         rtp->dtmfmute.tv_usec += (500 * 1000);
915         if (rtp->dtmfmute.tv_usec > 1000000) {
916                 rtp->dtmfmute.tv_usec -= 1000000;
917                 rtp->dtmfmute.tv_sec += 1;
918         }
919
920         ms = calc_txstamp(rtp, NULL);
921         /* Default prediction */
922         pred = rtp->lastts + ms * 8;
923         
924         /* Get a pointer to the header */
925         rtpheader = (unsigned int *)data;
926         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (101 << 16) | (rtp->seqno++));
927         rtpheader[1] = htonl(rtp->lastts);
928         rtpheader[2] = htonl(rtp->ssrc); 
929         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
930         for (x=0;x<4;x++) {
931                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
932                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
933                         if (res <0) 
934                                 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));
935         #if 0
936                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
937         #endif          
938                 }
939                 if (x ==0) {
940                         /* Clear marker bit and increment seqno */
941                         rtpheader[0] = htonl((2 << 30)  | (101 << 16) | (rtp->seqno++));
942                         /* Make duration 800 (100ms) */
943                         rtpheader[3] |= htonl((800));
944                         /* Set the End bit for the last 3 */
945                         rtpheader[3] |= htonl((1 << 23));
946                 }
947         }
948         return 0;
949 }
950
951 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
952 {
953         unsigned int *rtpheader;
954         int hdrlen = 12;
955         int res;
956         int ms;
957         int pred;
958         int mark = 0;
959
960         ms = calc_txstamp(rtp, &f->delivery);
961         /* Default prediction */
962         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
963                 pred = rtp->lastts + ms * 8;
964                 
965                 switch(f->subclass) {
966                 case AST_FORMAT_ULAW:
967                 case AST_FORMAT_ALAW:
968                         /* If we're within +/- 20ms from when where we
969                            predict we should be, use that */
970                         pred = rtp->lastts + f->datalen;
971                         break;
972                 case AST_FORMAT_ADPCM:
973                 case AST_FORMAT_G726:
974                         /* If we're within +/- 20ms from when where we
975                            predict we should be, use that */
976                         pred = rtp->lastts + f->datalen * 2;
977                         break;
978                 case AST_FORMAT_G729A:
979                         pred = rtp->lastts + f->datalen * 8;
980                         break;
981                 case AST_FORMAT_GSM:
982                         pred = rtp->lastts + (f->datalen * 160 / 33);
983                         break;
984                 case AST_FORMAT_ILBC:
985                         pred = rtp->lastts + (f->datalen * 240 / 50);
986                         break;
987                 case AST_FORMAT_G723_1:
988                         pred = rtp->lastts + g723_samples(f->data, f->datalen);
989                         break;
990                 case AST_FORMAT_SPEEX:
991                     pred = rtp->lastts + 160;
992                         // assumes that the RTP packet contains one Speex frame
993                         break;
994                 default:
995                         ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %s\n", ast_getformatname(f->subclass));
996                 }
997                 /* Re-calculate last TS */
998                 rtp->lastts = rtp->lastts + ms * 8;
999                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1000                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
1001                            and if so, go with our prediction */
1002                         if (abs(rtp->lastts - pred) < 640)
1003                                 rtp->lastts = pred;
1004                         else
1005                                 ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1006                 }
1007         } else {
1008                 mark = f->subclass & 0x1;
1009                 pred = rtp->lastovidtimestamp + f->samples;
1010                 /* Re-calculate last TS */
1011                 rtp->lastts = rtp->lastts + ms * 90;
1012                 /* If it's close to our prediction, go for it */
1013                 if (abs(rtp->lastts - pred) < 7200) {
1014                         rtp->lastts = pred;
1015                         rtp->lastovidtimestamp += f->samples;
1016                 } else {
1017                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1018                         rtp->lastovidtimestamp = rtp->lastts;
1019                 }
1020         }
1021         /* Get a pointer to the header */
1022         rtpheader = (unsigned int *)(f->data - hdrlen);
1023         rtpheader[0] = htonl((2 << 30) | (codec << 16) | (rtp->seqno++) | (mark << 23));
1024         rtpheader[1] = htonl(rtp->lastts);
1025         rtpheader[2] = htonl(rtp->ssrc); 
1026         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1027                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1028                 if (res <0) 
1029                         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));
1030 #if 0
1031                 printf("Sent %d bytes of RTP data to %s:%d\n", res, inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1032 #endif          
1033         }
1034         return 0;
1035 }
1036
1037 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1038 {
1039         struct ast_frame *f;
1040         int codec;
1041         int hdrlen = 12;
1042         int subclass;
1043         
1044
1045         /* If we have no peer, return immediately */    
1046         if (!rtp->them.sin_addr.s_addr)
1047                 return 0;
1048
1049         /* If there is no data length, return immediately */
1050         if (!_f->datalen) 
1051                 return 0;
1052         
1053         /* Make sure we have enough space for RTP header */
1054         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1055                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1056                 return -1;
1057         }
1058
1059         subclass = _f->subclass;
1060         if (_f->frametype == AST_FRAME_VIDEO)
1061                 subclass &= ~0x1;
1062
1063         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1064         if (codec < 0) {
1065                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1066                 return -1;
1067         }
1068
1069         if (rtp->lasttxformat != subclass) {
1070                 /* New format, reset the smoother */
1071                 ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1072                 rtp->lasttxformat = subclass;
1073                 if (rtp->smoother)
1074                         ast_smoother_free(rtp->smoother);
1075                 rtp->smoother = NULL;
1076         }
1077
1078
1079         switch(subclass) {
1080         case AST_FORMAT_ULAW:
1081         case AST_FORMAT_ALAW:
1082                 if (!rtp->smoother) {
1083                         rtp->smoother = ast_smoother_new(160);
1084                 }
1085                 if (!rtp->smoother) {
1086                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1087                         return -1;
1088                 }
1089                 ast_smoother_feed(rtp->smoother, _f);
1090                 
1091                 while((f = ast_smoother_read(rtp->smoother)))
1092                         ast_rtp_raw_write(rtp, f, codec);
1093                 break;
1094         case AST_FORMAT_ADPCM:
1095         case AST_FORMAT_G726:
1096                 if (!rtp->smoother) {
1097                         rtp->smoother = ast_smoother_new(80);
1098                 }
1099                 if (!rtp->smoother) {
1100                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1101                         return -1;
1102                 }
1103                 ast_smoother_feed(rtp->smoother, _f);
1104                 
1105                 while((f = ast_smoother_read(rtp->smoother)))
1106                         ast_rtp_raw_write(rtp, f, codec);
1107                 break;
1108         case AST_FORMAT_G729A:
1109                 if (!rtp->smoother) {
1110                         rtp->smoother = ast_smoother_new(20);
1111                         if (rtp->smoother)
1112                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1113                 }
1114                 if (!rtp->smoother) {
1115                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1116                         return -1;
1117                 }
1118                 ast_smoother_feed(rtp->smoother, _f);
1119                 
1120                 while((f = ast_smoother_read(rtp->smoother)))
1121                         ast_rtp_raw_write(rtp, f, codec);
1122                 break;
1123         case AST_FORMAT_GSM:
1124                 if (!rtp->smoother) {
1125                         rtp->smoother = ast_smoother_new(33);
1126                 }
1127                 if (!rtp->smoother) {
1128                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1129                         return -1;
1130                 }
1131                 ast_smoother_feed(rtp->smoother, _f);
1132                 while((f = ast_smoother_read(rtp->smoother)))
1133                         ast_rtp_raw_write(rtp, f, codec);
1134                 break;
1135         case AST_FORMAT_ILBC:
1136                 if (!rtp->smoother) {
1137                         rtp->smoother = ast_smoother_new(50);
1138                 }
1139                 if (!rtp->smoother) {
1140                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1141                         return -1;
1142                 }
1143                 ast_smoother_feed(rtp->smoother, _f);
1144                 while((f = ast_smoother_read(rtp->smoother)))
1145                         ast_rtp_raw_write(rtp, f, codec);
1146                 break;
1147         default:        
1148                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1149                 // fall through to...
1150         case AST_FORMAT_H261:
1151         case AST_FORMAT_H263:
1152         case AST_FORMAT_G723_1:
1153         case AST_FORMAT_SPEEX:
1154                 // Don't buffer outgoing frames; send them one-per-packet:
1155                 if (_f->offset < hdrlen) {
1156                         f = ast_frdup(_f);
1157                 } else {
1158                         f = _f;
1159                 }
1160                 ast_rtp_raw_write(rtp, f, codec);
1161         }
1162                 
1163         return 0;
1164 }
1165
1166 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1167 {
1168         struct ast_rtp_protocol *cur, *prev;
1169         cur = protos;
1170         prev = NULL;
1171         while(cur) {
1172                 if (cur == proto) {
1173                         if (prev)
1174                                 prev->next = proto->next;
1175                         else
1176                                 protos = proto->next;
1177                         return;
1178                 }
1179                 prev = cur;
1180                 cur = cur->next;
1181         }
1182 }
1183
1184 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1185 {
1186         struct ast_rtp_protocol *cur;
1187         cur = protos;
1188         while(cur) {
1189                 if (cur->type == proto->type) {
1190                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1191                         return -1;
1192                 }
1193                 cur = cur->next;
1194         }
1195         proto->next = protos;
1196         protos = proto;
1197         return 0;
1198 }
1199
1200 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1201 {
1202         struct ast_rtp_protocol *cur;
1203         cur = protos;
1204         while(cur) {
1205                 if (cur->type == chan->type) {
1206                         return cur;
1207                 }
1208                 cur = cur->next;
1209         }
1210         return NULL;
1211 }
1212
1213 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1214 {
1215         struct ast_frame *f;
1216         struct ast_channel *who, *cs[3];
1217         struct ast_rtp *p0, *p1;
1218         struct ast_rtp *vp0, *vp1;
1219         struct ast_rtp_protocol *pr0, *pr1;
1220         struct sockaddr_in ac0, ac1;
1221         struct sockaddr_in vac0, vac1;
1222         struct sockaddr_in t0, t1;
1223         struct sockaddr_in vt0, vt1;
1224         
1225         void *pvt0, *pvt1;
1226         int to;
1227         memset(&vt0, 0, sizeof(vt0));
1228         memset(&vt1, 0, sizeof(vt1));
1229         memset(&vac0, 0, sizeof(vac0));
1230         memset(&vac1, 0, sizeof(vac1));
1231
1232         /* XXX Wait a half a second for things to settle up 
1233                         this really should be fixed XXX */
1234         ast_autoservice_start(c0);
1235         ast_autoservice_start(c1);
1236         usleep(500000);
1237         ast_autoservice_stop(c0);
1238         ast_autoservice_stop(c1);
1239
1240         /* if need DTMF, cant native bridge */
1241         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1242                 return -2;
1243         ast_mutex_lock(&c0->lock);
1244         ast_mutex_lock(&c1->lock);
1245         pr0 = get_proto(c0);
1246         pr1 = get_proto(c1);
1247         if (!pr0) {
1248                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1249                 ast_mutex_unlock(&c0->lock);
1250                 ast_mutex_unlock(&c1->lock);
1251                 return -1;
1252         }
1253         if (!pr1) {
1254                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1255                 ast_mutex_unlock(&c0->lock);
1256                 ast_mutex_unlock(&c1->lock);
1257                 return -1;
1258         }
1259         pvt0 = c0->pvt->pvt;
1260         pvt1 = c1->pvt->pvt;
1261         p0 = pr0->get_rtp_info(c0);
1262         if (pr0->get_vrtp_info)
1263                 vp0 = pr0->get_vrtp_info(c0);
1264         else
1265                 vp0 = NULL;
1266         p1 = pr1->get_rtp_info(c1);
1267         if (pr1->get_vrtp_info)
1268                 vp1 = pr1->get_vrtp_info(c1);
1269         else
1270                 vp1 = NULL;
1271         if (!p0 || !p1) {
1272                 /* Somebody doesn't want to play... */
1273                 ast_mutex_unlock(&c0->lock);
1274                 ast_mutex_unlock(&c1->lock);
1275                 return -2;
1276         }
1277         if (pr0->get_codec && pr1->get_codec) {
1278                 int codec0,codec1;
1279                 codec0 = pr0->get_codec(c0);
1280                 codec1 = pr1->get_codec(c1);
1281                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1282                 if (!(codec0 & codec1)) {
1283                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1284                         ast_mutex_unlock(&c0->lock);
1285                         ast_mutex_unlock(&c1->lock);
1286                         return -2;
1287                 }
1288         }
1289         if (pr0->set_rtp_peer(c0, p1, vp1)) 
1290                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1291         else {
1292                 /* Store RTP peer */
1293                 ast_rtp_get_peer(p1, &ac1);
1294                 if (vp1)
1295                         ast_rtp_get_peer(p1, &vac1);
1296         }
1297         if (pr1->set_rtp_peer(c1, p0, vp0))
1298                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1299         else {
1300                 /* Store RTP peer */
1301                 ast_rtp_get_peer(p0, &ac0);
1302                 if (vp0)
1303                         ast_rtp_get_peer(p0, &vac0);
1304         }
1305         ast_mutex_unlock(&c0->lock);
1306         ast_mutex_unlock(&c1->lock);
1307         cs[0] = c0;
1308         cs[1] = c1;
1309         cs[2] = NULL;
1310         for (;;) {
1311                 if ((c0->pvt->pvt != pvt0)  ||
1312                         (c1->pvt->pvt != pvt1) ||
1313                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1314                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1315                                 if (c0->pvt->pvt == pvt0) {
1316                                         if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1317                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1318                                 }
1319                                 if (c1->pvt->pvt == pvt1) {
1320                                         if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1321                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1322                                 }
1323                                 /* Tell it to try again later */
1324                                 return -3;
1325                 }
1326                 to = -1;
1327                 ast_rtp_get_peer(p1, &t1);
1328                 ast_rtp_get_peer(p0, &t0);
1329                 if (vp1)
1330                         ast_rtp_get_peer(vp1, &vt1);
1331                 if (vp0)
1332                         ast_rtp_get_peer(vp0, &vt0);
1333                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1))) {
1334                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c1->name);
1335                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL)) 
1336                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1337                         memcpy(&ac1, &t1, sizeof(ac1));
1338                         memcpy(&vac1, &vt1, sizeof(vac1));
1339                 }
1340                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1341                         ast_log(LOG_DEBUG, "Oooh, '%s' changed end address\n", c0->name);
1342                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL))
1343                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1344                         memcpy(&ac0, &t0, sizeof(ac0));
1345                         memcpy(&vac0, &vt0, sizeof(vac0));
1346                 }
1347                 who = ast_waitfor_n(cs, 2, &to);
1348                 if (!who) {
1349                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1350                         /* check for hagnup / whentohangup */
1351                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1352                                 break;
1353                         continue;
1354                 }
1355                 f = ast_read(who);
1356                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1357                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
1358                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1359                         *fo = f;
1360                         *rc = who;
1361                         ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1362                         if ((c0->pvt->pvt == pvt0) && (!c0->_softhangup)) {
1363                                 if (pr0->set_rtp_peer(c0, NULL, NULL)) 
1364                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1365                         }
1366                         if ((c1->pvt->pvt == pvt1) && (!c1->_softhangup)) {
1367                                 if (pr1->set_rtp_peer(c1, NULL, NULL)) 
1368                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1369                         }
1370                         /* That's all we needed */
1371                         return 0;
1372                 } else {
1373                         if ((f->frametype == AST_FRAME_DTMF) || 
1374                                 (f->frametype == AST_FRAME_VOICE) || 
1375                                 (f->frametype == AST_FRAME_VIDEO)) {
1376                                 /* Forward voice or DTMF frames if they happen upon us */
1377                                 if (who == c0) {
1378                                         ast_write(c1, f);
1379                                 } else if (who == c1) {
1380                                         ast_write(c0, f);
1381                                 }
1382                         }
1383                         ast_frfree(f);
1384                 }
1385                 /* Swap priority not that it's a big deal at this point */
1386                 cs[2] = cs[0];
1387                 cs[0] = cs[1];
1388                 cs[1] = cs[2];
1389                 
1390         }
1391         return -1;
1392 }
1393
1394 void ast_rtp_reload(void)
1395 {
1396         struct ast_config *cfg;
1397         char *s;
1398         rtpstart = 5000;
1399         rtpend = 31000;
1400         cfg = ast_load("rtp.conf");
1401         if (cfg) {
1402                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1403                         rtpstart = atoi(s);
1404                         if (rtpstart < 1024)
1405                                 rtpstart = 1024;
1406                         if (rtpstart > 65535)
1407                                 rtpstart = 65535;
1408                 }
1409                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1410                         rtpend = atoi(s);
1411                         if (rtpend < 1024)
1412                                 rtpend = 1024;
1413                         if (rtpend > 65535)
1414                                 rtpend = 65535;
1415                 }
1416                 ast_destroy(cfg);
1417         }
1418         if (rtpstart >= rtpend) {
1419                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end\n");
1420                 rtpstart = 5000;
1421                 rtpend = 31000;
1422         }
1423         if (option_verbose > 1)
1424                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1425 }
1426
1427 void ast_rtp_init(void)
1428 {
1429         ast_rtp_reload();
1430 }