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