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