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