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