ab55a0590bd9d3429ff0270ddd701c46f649f56e
[asterisk/asterisk.git] / main / rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  * 
26  * \note RTP is defined in RFC 3550.
27  */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <netinet/in.h>
41 #include <sys/time.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
44 #include <fcntl.h>
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/netsock.h"
57 #include "asterisk/cli.h"
58 #include "asterisk/manager.h"
59 #include "asterisk/unaligned.h"
60 #include "asterisk/utils.h"
61
62 #define MAX_TIMESTAMP_SKEW      640
63
64 #define RTP_SEQ_MOD     (1<<16)         /*!< A sequence number can't be more than 16 bits */
65 #define RTCP_DEFAULT_INTERVALMS   5000  /*!< Default milli-seconds between RTCP reports we send */
66 #define RTCP_MIN_INTERVALMS       500   /*!< Min milli-seconds between RTCP reports we send */
67 #define RTCP_MAX_INTERVALMS       60000 /*!< Max milli-seconds between RTCP reports we send */
68
69 #define RTCP_PT_FUR     192
70 #define RTCP_PT_SR      200
71 #define RTCP_PT_RR      201
72 #define RTCP_PT_SDES    202
73 #define RTCP_PT_BYE     203
74 #define RTCP_PT_APP     204
75
76 #define RTP_MTU         1200
77
78 #define DEFAULT_DTMF_TIMEOUT 3000       /*!< samples */
79
80 static int dtmftimeout = DEFAULT_DTMF_TIMEOUT;
81
82 static int rtpstart;                    /*!< First port for RTP sessions (set in rtp.conf) */
83 static int rtpend;                      /*!< Last port for RTP sessions (set in rtp.conf) */
84 static int rtpdebug;                    /*!< Are we debugging? */
85 static int rtcpdebug;                   /*!< Are we debugging RTCP? */
86 static int rtcpstats;                   /*!< Are we debugging RTCP? */
87 static int rtcpinterval = RTCP_DEFAULT_INTERVALMS; /*!< Time between rtcp reports in millisecs */
88 static int stundebug;                   /*!< Are we debugging stun? */
89 static struct sockaddr_in rtpdebugaddr; /*!< Debug packets to/from this host */
90 static struct sockaddr_in rtcpdebugaddr;        /*!< Debug RTCP packets to/from this host */
91 #ifdef SO_NO_CHECK
92 static int nochecksums;
93 #endif
94
95 /* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
96 /* #define P2P_INTENSE */
97
98 /*!
99  * \brief Structure representing a RTP session.
100  *
101  * RTP session is defined on page 9 of RFC 3550: "An association among a set of participants communicating with RTP.  A participant may be involved in multiple RTP sessions at the same time [...]"
102  *
103  */
104 /*! \brief The value of each payload format mapping: */
105 struct rtpPayloadType {
106         int isAstFormat;        /*!< whether the following code is an AST_FORMAT */
107         int code;
108 };
109
110
111 /*! \brief RTP session description */
112 struct ast_rtp {
113         int s;
114         struct ast_frame f;
115         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
116         unsigned int ssrc;              /*!< Synchronization source, RFC 3550, page 10. */
117         unsigned int themssrc;          /*!< Their SSRC */
118         unsigned int rxssrc;
119         unsigned int lastts;
120         unsigned int lastrxts;
121         unsigned int lastividtimestamp;
122         unsigned int lastovidtimestamp;
123         unsigned int lastitexttimestamp;
124         unsigned int lastotexttimestamp;
125         unsigned int lasteventseqn;
126         int lastrxseqno;                /*!< Last received sequence number */
127         unsigned short seedrxseqno;     /*!< What sequence number did they start with?*/
128         unsigned int seedrxts;          /*!< What RTP timestamp did they start with? */
129         unsigned int rxcount;           /*!< How many packets have we received? */
130         unsigned int rxoctetcount;      /*!< How many octets have we received? should be rxcount *160*/
131         unsigned int txcount;           /*!< How many packets have we sent? */
132         unsigned int txoctetcount;      /*!< How many octets have we sent? (txcount*160)*/
133         unsigned int cycles;            /*!< Shifted count of sequence number cycles */
134         double rxjitter;                /*!< Interarrival jitter at the moment */
135         double rxtransit;               /*!< Relative transit time for previous packet */
136         int lasttxformat;
137         int lastrxformat;
138
139         int rtptimeout;                 /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
140         int rtpholdtimeout;             /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
141         int rtpkeepalive;               /*!< Send RTP comfort noice packets for keepalive */
142
143         /* DTMF Reception Variables */
144         char resp;
145         unsigned int lastevent;
146         int dtmfcount;
147         unsigned int dtmfsamples;
148         /* DTMF Transmission Variables */
149         unsigned int lastdigitts;
150         char sending_digit;     /*!< boolean - are we sending digits */
151         char send_digit;        /*!< digit we are sending */
152         int send_payload;
153         int send_duration;
154         int nat;
155         unsigned int flags;
156         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
157         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
158         struct timeval rxcore;
159         struct timeval txcore;
160         double drxcore;                 /*!< The double representation of the first received packet */
161         struct timeval lastrx;          /*!< timeval when we last received a packet */
162         struct timeval dtmfmute;
163         struct ast_smoother *smoother;
164         int *ioid;
165         unsigned short seqno;           /*!< Sequence number, RFC 3550, page 13. */
166         unsigned short rxseqno;
167         struct sched_context *sched;
168         struct io_context *io;
169         void *data;
170         ast_rtp_callback callback;
171 #ifdef P2P_INTENSE
172         ast_mutex_t bridge_lock;
173 #endif
174         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
175         int rtp_lookup_code_cache_isAstFormat; /*!< a cache for the result of rtp_lookup_code(): */
176         int rtp_lookup_code_cache_code;
177         int rtp_lookup_code_cache_result;
178         struct ast_rtcp *rtcp;
179         struct ast_codec_pref pref;
180         struct ast_rtp *bridged;        /*!< Who we are Packet bridged to */
181 };
182
183 /* Forward declarations */
184 static int ast_rtcp_write(void *data);
185 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw);
186 static int ast_rtcp_write_sr(void *data);
187 static int ast_rtcp_write_rr(void *data);
188 static unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp);
189 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp);
190 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit);
191
192 #define FLAG_3389_WARNING               (1 << 0)
193 #define FLAG_NAT_ACTIVE                 (3 << 1)
194 #define FLAG_NAT_INACTIVE               (0 << 1)
195 #define FLAG_NAT_INACTIVE_NOWARN        (1 << 1)
196 #define FLAG_HAS_DTMF                   (1 << 3)
197 #define FLAG_P2P_SENT_MARK              (1 << 4)
198 #define FLAG_P2P_NEED_DTMF              (1 << 5)
199 #define FLAG_CALLBACK_MODE              (1 << 6)
200 #define FLAG_DTMF_COMPENSATE            (1 << 7)
201 #define FLAG_HAS_STUN                   (1 << 8)
202
203 /*!
204  * \brief Structure defining an RTCP session.
205  * 
206  * The concept "RTCP session" is not defined in RFC 3550, but since 
207  * this structure is analogous to ast_rtp, which tracks a RTP session, 
208  * it is logical to think of this as a RTCP session.
209  *
210  * RTCP packet is defined on page 9 of RFC 3550.
211  * 
212  */
213 struct ast_rtcp {
214         int s;                          /*!< Socket */
215         struct sockaddr_in us;          /*!< Socket representation of the local endpoint. */
216         struct sockaddr_in them;        /*!< Socket representation of the remote endpoint. */
217         unsigned int soc;               /*!< What they told us */
218         unsigned int spc;               /*!< What they told us */
219         unsigned int themrxlsr;         /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
220         struct timeval rxlsr;           /*!< Time when we got their last SR */
221         struct timeval txlsr;           /*!< Time when we sent or last SR*/
222         unsigned int expected_prior;    /*!< no. packets in previous interval */
223         unsigned int received_prior;    /*!< no. packets received in previous interval */
224         int schedid;                    /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
225         unsigned int rr_count;          /*!< number of RRs we've sent, not including report blocks in SR's */
226         unsigned int sr_count;          /*!< number of SRs we've sent */
227         unsigned int lastsrtxcount;     /*!< Transmit packet count when last SR sent */
228         double accumulated_transit;     /*!< accumulated a-dlsr-lsr */
229         double rtt;                     /*!< Last reported rtt */
230         unsigned int reported_jitter;   /*!< The contents of their last jitter entry in the RR */
231         unsigned int reported_lost;     /*!< Reported lost packets in their RR */
232         char quality[AST_MAX_USER_FIELD];
233         double maxrxjitter;
234         double minrxjitter;
235         double maxrtt;
236         double minrtt;
237         int sendfur;
238 };
239
240
241 typedef struct { unsigned int id[4]; } __attribute__((packed)) stun_trans_id;
242
243 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
244 struct stun_header {
245         unsigned short msgtype;
246         unsigned short msglen;
247         stun_trans_id  id;
248         unsigned char ies[0];
249 } __attribute__((packed));
250
251 struct stun_attr {
252         unsigned short attr;
253         unsigned short len;
254         unsigned char value[0];
255 } __attribute__((packed));
256
257 struct stun_addr {
258         unsigned char unused;
259         unsigned char family;
260         unsigned short port;
261         unsigned int addr;
262 } __attribute__((packed));
263
264 #define STUN_IGNORE             (0)
265 #define STUN_ACCEPT             (1)
266
267 #define STUN_BINDREQ    0x0001
268 #define STUN_BINDRESP   0x0101
269 #define STUN_BINDERR    0x0111
270 #define STUN_SECREQ     0x0002
271 #define STUN_SECRESP    0x0102
272 #define STUN_SECERR     0x0112
273
274 #define STUN_MAPPED_ADDRESS     0x0001
275 #define STUN_RESPONSE_ADDRESS   0x0002
276 #define STUN_CHANGE_REQUEST     0x0003
277 #define STUN_SOURCE_ADDRESS     0x0004
278 #define STUN_CHANGED_ADDRESS    0x0005
279 #define STUN_USERNAME           0x0006
280 #define STUN_PASSWORD           0x0007
281 #define STUN_MESSAGE_INTEGRITY  0x0008
282 #define STUN_ERROR_CODE         0x0009
283 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
284 #define STUN_REFLECTED_FROM     0x000b
285
286 static const char *stun_msg2str(int msg)
287 {
288         switch (msg) {
289         case STUN_BINDREQ:
290                 return "Binding Request";
291         case STUN_BINDRESP:
292                 return "Binding Response";
293         case STUN_BINDERR:
294                 return "Binding Error Response";
295         case STUN_SECREQ:
296                 return "Shared Secret Request";
297         case STUN_SECRESP:
298                 return "Shared Secret Response";
299         case STUN_SECERR:
300                 return "Shared Secret Error Response";
301         }
302         return "Non-RFC3489 Message";
303 }
304
305 static const char *stun_attr2str(int msg)
306 {
307         switch (msg) {
308         case STUN_MAPPED_ADDRESS:
309                 return "Mapped Address";
310         case STUN_RESPONSE_ADDRESS:
311                 return "Response Address";
312         case STUN_CHANGE_REQUEST:
313                 return "Change Request";
314         case STUN_SOURCE_ADDRESS:
315                 return "Source Address";
316         case STUN_CHANGED_ADDRESS:
317                 return "Changed Address";
318         case STUN_USERNAME:
319                 return "Username";
320         case STUN_PASSWORD:
321                 return "Password";
322         case STUN_MESSAGE_INTEGRITY:
323                 return "Message Integrity";
324         case STUN_ERROR_CODE:
325                 return "Error Code";
326         case STUN_UNKNOWN_ATTRIBUTES:
327                 return "Unknown Attributes";
328         case STUN_REFLECTED_FROM:
329                 return "Reflected From";
330         }
331         return "Non-RFC3489 Attribute";
332 }
333
334 struct stun_state {
335         const char *username;
336         const char *password;
337 };
338
339 static int stun_process_attr(struct stun_state *state, struct stun_attr *attr)
340 {
341         if (stundebug)
342                 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
343                             stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
344         switch (ntohs(attr->attr)) {
345         case STUN_USERNAME:
346                 state->username = (const char *) (attr->value);
347                 break;
348         case STUN_PASSWORD:
349                 state->password = (const char *) (attr->value);
350                 break;
351         default:
352                 if (stundebug)
353                         ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n", 
354                                     stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr), ntohs(attr->len));
355         }
356         return 0;
357 }
358
359 static void append_attr_string(struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
360 {
361         int size = sizeof(**attr) + strlen(s);
362         if (*left > size) {
363                 (*attr)->attr = htons(attrval);
364                 (*attr)->len = htons(strlen(s));
365                 memcpy((*attr)->value, s, strlen(s));
366                 (*attr) = (struct stun_attr *)((*attr)->value + strlen(s));
367                 *len += size;
368                 *left -= size;
369         }
370 }
371
372 static void append_attr_address(struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
373 {
374         int size = sizeof(**attr) + 8;
375         struct stun_addr *addr;
376         if (*left > size) {
377                 (*attr)->attr = htons(attrval);
378                 (*attr)->len = htons(8);
379                 addr = (struct stun_addr *)((*attr)->value);
380                 addr->unused = 0;
381                 addr->family = 0x01;
382                 addr->port = sin->sin_port;
383                 addr->addr = sin->sin_addr.s_addr;
384                 (*attr) = (struct stun_attr *)((*attr)->value + 8);
385                 *len += size;
386                 *left -= size;
387         }
388 }
389
390 static int stun_send(int s, struct sockaddr_in *dst, struct stun_header *resp)
391 {
392         return sendto(s, resp, ntohs(resp->msglen) + sizeof(*resp), 0,
393                       (struct sockaddr *)dst, sizeof(*dst));
394 }
395
396 static void stun_req_id(struct stun_header *req)
397 {
398         int x;
399         for (x = 0; x < 4; x++)
400                 req->id.id[x] = ast_random();
401 }
402
403 size_t ast_rtp_alloc_size(void)
404 {
405         return sizeof(struct ast_rtp);
406 }
407
408 void ast_rtp_stun_request(struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
409 {
410         struct stun_header *req;
411         unsigned char reqdata[1024];
412         int reqlen, reqleft;
413         struct stun_attr *attr;
414         
415         req = (struct stun_header *)reqdata;
416         stun_req_id(req);
417         reqlen = 0;
418         reqleft = sizeof(reqdata) - sizeof(struct stun_header);
419         req->msgtype = 0;
420         req->msglen = 0;
421         attr = (struct stun_attr *)req->ies;
422         if (username)
423                 append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft);
424         req->msglen = htons(reqlen);
425         req->msgtype = htons(STUN_BINDREQ);
426         stun_send(rtp->s, suggestion, req);
427 }
428
429 static int stun_handle_packet(int s, struct sockaddr_in *src, unsigned char *data, size_t len)
430 {
431         struct stun_header *resp, *hdr = (struct stun_header *)data;
432         struct stun_attr *attr;
433         struct stun_state st;
434         int ret = STUN_IGNORE;  
435         unsigned char respdata[1024];
436         int resplen, respleft;
437         
438         if (len < sizeof(struct stun_header)) {
439                 ast_debug(1, "Runt STUN packet (only %d, wanting at least %d)\n", (int) len, (int) sizeof(struct stun_header));
440                 return -1;
441         }
442         if (stundebug)
443                 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr->msgtype)), ntohs(hdr->msgtype), ntohs(hdr->msglen));
444         if (ntohs(hdr->msglen) > len - sizeof(struct stun_header)) {
445                 ast_debug(1, "Scrambled STUN packet length (got %d, expecting %d)\n", ntohs(hdr->msglen), (int)(len - sizeof(struct stun_header)));
446         } else
447                 len = ntohs(hdr->msglen);
448         data += sizeof(struct stun_header);
449         memset(&st, 0, sizeof(st));
450         while (len) {
451                 if (len < sizeof(struct stun_attr)) {
452                         ast_debug(1, "Runt Attribute (got %d, expecting %d)\n", (int)len, (int) sizeof(struct stun_attr));
453                         break;
454                 }
455                 attr = (struct stun_attr *)data;
456                 if (ntohs(attr->len) > len) {
457                         ast_debug(1, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", ntohs(attr->len), (int)len);
458                         break;
459                 }
460                 if (stun_process_attr(&st, attr)) {
461                         ast_debug(1, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr->attr)), ntohs(attr->attr));
462                         break;
463                 }
464                 /* Clear attribute in case previous entry was a string */
465                 attr->attr = 0;
466                 data += ntohs(attr->len) + sizeof(struct stun_attr);
467                 len -= ntohs(attr->len) + sizeof(struct stun_attr);
468         }
469         /* Null terminate any string */
470         *data = '\0';
471         resp = (struct stun_header *)respdata;
472         resplen = 0;
473         respleft = sizeof(respdata) - sizeof(struct stun_header);
474         resp->id = hdr->id;
475         resp->msgtype = 0;
476         resp->msglen = 0;
477         attr = (struct stun_attr *)resp->ies;
478         if (!len) {
479                 switch (ntohs(hdr->msgtype)) {
480                 case STUN_BINDREQ:
481                         if (stundebug)
482                                 ast_verbose("STUN Bind Request, username: %s\n", 
483                                             st.username ? st.username : "<none>");
484                         if (st.username)
485                                 append_attr_string(&attr, STUN_USERNAME, st.username, &resplen, &respleft);
486                         append_attr_address(&attr, STUN_MAPPED_ADDRESS, src, &resplen, &respleft);
487                         resp->msglen = htons(resplen);
488                         resp->msgtype = htons(STUN_BINDRESP);
489                         stun_send(s, src, resp);
490                         ret = STUN_ACCEPT;
491                         break;
492                 default:
493                         if (stundebug)
494                                 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr->msgtype), stun_msg2str(ntohs(hdr->msgtype)));
495                 }
496         }
497         return ret;
498 }
499
500 /*! \brief List of current sessions */
501 static AST_RWLIST_HEAD_STATIC(protos, ast_rtp_protocol);
502
503 static void timeval2ntp(struct timeval tv, unsigned int *msw, unsigned int *lsw)
504 {
505         unsigned int sec, usec, frac;
506         sec = tv.tv_sec + 2208988800u; /* Sec between 1900 and 1970 */
507         usec = tv.tv_usec;
508         frac = (usec << 12) + (usec << 8) - ((usec * 3650) >> 6);
509         *msw = sec;
510         *lsw = frac;
511 }
512
513 int ast_rtp_fd(struct ast_rtp *rtp)
514 {
515         return rtp->s;
516 }
517
518 int ast_rtcp_fd(struct ast_rtp *rtp)
519 {
520         if (rtp->rtcp)
521                 return rtp->rtcp->s;
522         return -1;
523 }
524
525 unsigned int ast_rtcp_calc_interval(struct ast_rtp *rtp)
526 {
527         unsigned int interval;
528         /*! \todo XXX Do a more reasonable calculation on this one
529          * Look in RFC 3550 Section A.7 for an example*/
530         interval = rtcpinterval;
531         return interval;
532 }
533
534 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
535 void ast_rtp_set_rtptimers_onhold(struct ast_rtp *rtp)
536 {
537         rtp->rtptimeout = (-1) * rtp->rtptimeout;
538         rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout;
539 }
540
541 /*! \brief Set rtp timeout */
542 void ast_rtp_set_rtptimeout(struct ast_rtp *rtp, int timeout)
543 {
544         rtp->rtptimeout = timeout;
545 }
546
547 /*! \brief Set rtp hold timeout */
548 void ast_rtp_set_rtpholdtimeout(struct ast_rtp *rtp, int timeout)
549 {
550         rtp->rtpholdtimeout = timeout;
551 }
552
553 /*! \brief set RTP keepalive interval */
554 void ast_rtp_set_rtpkeepalive(struct ast_rtp *rtp, int period)
555 {
556         rtp->rtpkeepalive = period;
557 }
558
559 /*! \brief Get rtp timeout */
560 int ast_rtp_get_rtptimeout(struct ast_rtp *rtp)
561 {
562         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
563                 return 0;
564         return rtp->rtptimeout;
565 }
566
567 /*! \brief Get rtp hold timeout */
568 int ast_rtp_get_rtpholdtimeout(struct ast_rtp *rtp)
569 {
570         if (rtp->rtptimeout < 0)        /* We're not checking, but remembering the setting (during T.38 transmission) */
571                 return 0;
572         return rtp->rtpholdtimeout;
573 }
574
575 /*! \brief Get RTP keepalive interval */
576 int ast_rtp_get_rtpkeepalive(struct ast_rtp *rtp)
577 {
578         return rtp->rtpkeepalive;
579 }
580
581 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
582 {
583         rtp->data = data;
584 }
585
586 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
587 {
588         rtp->callback = callback;
589 }
590
591 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
592 {
593         rtp->nat = nat;
594 }
595
596 int ast_rtp_getnat(struct ast_rtp *rtp)
597 {
598         return ast_test_flag(rtp, FLAG_NAT_ACTIVE);
599 }
600
601 void ast_rtp_setdtmf(struct ast_rtp *rtp, int dtmf)
602 {
603         ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF);
604 }
605
606 void ast_rtp_setdtmfcompensate(struct ast_rtp *rtp, int compensate)
607 {
608         ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE);
609 }
610
611 void ast_rtp_setstun(struct ast_rtp *rtp, int stun_enable)
612 {
613         ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN);
614 }
615
616 static void rtp_bridge_lock(struct ast_rtp *rtp)
617 {
618 #ifdef P2P_INTENSE
619         ast_mutex_lock(&rtp->bridge_lock);
620 #endif
621         return;
622 }
623
624 static void rtp_bridge_unlock(struct ast_rtp *rtp)
625 {
626 #ifdef P2P_INTENSE
627         ast_mutex_unlock(&rtp->bridge_lock);
628 #endif
629         return;
630 }
631
632 static struct ast_frame *send_dtmf(struct ast_rtp *rtp, enum ast_frame_type type)
633 {
634         if (((ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && type == AST_FRAME_DTMF_END) ||
635              (type == AST_FRAME_DTMF_BEGIN)) && ast_tvcmp(ast_tvnow(), rtp->dtmfmute) < 0) {
636                 ast_debug(1, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp->them.sin_addr));
637                 rtp->resp = 0;
638                 rtp->dtmfsamples = 0;
639                 return &ast_null_frame;
640         }
641         ast_debug(1, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(rtp->them.sin_addr));
642         if (rtp->resp == 'X') {
643                 rtp->f.frametype = AST_FRAME_CONTROL;
644                 rtp->f.subclass = AST_CONTROL_FLASH;
645         } else {
646                 rtp->f.frametype = type;
647                 rtp->f.subclass = rtp->resp;
648         }
649         rtp->f.datalen = 0;
650         rtp->f.samples = 0;
651         rtp->f.mallocd = 0;
652         rtp->f.src = "RTP";
653         return &rtp->f;
654         
655 }
656
657 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
658 {
659         if (rtpdebug == 0)
660                 return 0;
661         if (rtpdebugaddr.sin_addr.s_addr) {
662                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
663                      && (rtpdebugaddr.sin_port != addr->sin_port))
664                     || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
665                         return 0;
666         }
667         return 1;
668 }
669
670 static inline int rtcp_debug_test_addr(struct sockaddr_in *addr)
671 {
672         if (rtcpdebug == 0)
673                 return 0;
674         if (rtcpdebugaddr.sin_addr.s_addr) {
675                 if (((ntohs(rtcpdebugaddr.sin_port) != 0)
676                      && (rtcpdebugaddr.sin_port != addr->sin_port))
677                     || (rtcpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
678                         return 0;
679         }
680         return 1;
681 }
682
683
684 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
685 {
686         unsigned int event;
687         char resp = 0;
688         struct ast_frame *f = NULL;
689         unsigned char seq;
690         unsigned int flags;
691         unsigned int power;
692
693         /* We should have at least 4 bytes in RTP data */
694         if (len < 4)
695                 return f;
696
697         /*      The format of Cisco RTP DTMF packet looks like next:
698                 +0                              - sequence number of DTMF RTP packet (begins from 1,
699                                                   wrapped to 0)
700                 +1                              - set of flags
701                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
702                                                   or repeated digit without audio???
703                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
704                                                   then falls to 0 at its end)
705                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
706                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
707                 by each new packet and thus provides some redudancy.
708                 
709                 Sample of Cisco RTP DTMF packet is (all data in hex):
710                         19 07 00 02 12 02 20 02
711                 showing end of DTMF digit '2'.
712
713                 The packets
714                         27 07 00 02 0A 02 20 02
715                         28 06 20 02 00 02 0A 02
716                 shows begin of new digit '2' with very short pause (20 ms) after
717                 previous digit '2'. Bit +1.0 flips at begin of new digit.
718                 
719                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
720                 so its uses the same sequencing and timestamping rules as replaced
721                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
722                 on audio framing parameters. Marker bit isn't used within stream of
723                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
724                 are not sequential at borders between DTMF and audio streams,
725         */
726
727         seq = data[0];
728         flags = data[1];
729         power = data[2];
730         event = data[3] & 0x1f;
731
732         if (option_debug > 2 || rtpdebug)
733                 ast_debug(0, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
734         if (event < 10) {
735                 resp = '0' + event;
736         } else if (event < 11) {
737                 resp = '*';
738         } else if (event < 12) {
739                 resp = '#';
740         } else if (event < 16) {
741                 resp = 'A' + (event - 12);
742         } else if (event < 17) {
743                 resp = 'X';
744         }
745         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
746                 rtp->resp = resp;
747                 /* Why we should care on DTMF compensation at reception? */
748                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
749                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
750                         rtp->dtmfsamples = 0;
751                 }
752         } else if ((rtp->resp == resp) && !power) {
753                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
754                 f->samples = rtp->dtmfsamples * 8;
755                 rtp->resp = 0;
756         } else if (rtp->resp == resp)
757                 rtp->dtmfsamples += 20 * 8;
758         rtp->dtmfcount = dtmftimeout;
759         return f;
760 }
761
762 /*! 
763  * \brief Process RTP DTMF and events according to RFC 2833.
764  * 
765  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
766  * 
767  * \param rtp
768  * \param data
769  * \param len
770  * \param seqno
771  * \param timestamp
772  * \returns
773  */
774 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno, unsigned int timestamp)
775 {
776         unsigned int event;
777         unsigned int event_end;
778         unsigned int samples;
779         char resp = 0;
780         struct ast_frame *f = NULL;
781
782         /* Figure out event, event end, and samples */
783         event = ntohl(*((unsigned int *)(data)));
784         event >>= 24;
785         event_end = ntohl(*((unsigned int *)(data)));
786         event_end <<= 8;
787         event_end >>= 24;
788         samples = ntohl(*((unsigned int *)(data)));
789         samples &= 0xFFFF;
790
791         /* Print out debug if turned on */
792         if (rtpdebug || option_debug > 2)
793                 ast_debug(0, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
794
795         /* Figure out what digit was pressed */
796         if (event < 10) {
797                 resp = '0' + event;
798         } else if (event < 11) {
799                 resp = '*';
800         } else if (event < 12) {
801                 resp = '#';
802         } else if (event < 16) {
803                 resp = 'A' + (event - 12);
804         } else if (event < 17) {        /* Event 16: Hook flash */
805                 resp = 'X';     
806         }
807         
808         if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
809                 if ((rtp->lastevent != timestamp) || (rtp->resp && rtp->resp != resp)) {
810                         rtp->resp = resp;
811                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
812                         f->len = 0;
813                         rtp->lastevent = timestamp;
814                 }
815         } else {
816                 if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
817                         rtp->resp = resp;
818                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
819                 } else if ((event_end & 0x80) && (rtp->lastevent != seqno) && rtp->resp) {
820                         f = send_dtmf(rtp, AST_FRAME_DTMF_END);
821                         f->len = ast_tvdiff_ms(ast_samp2tv(samples, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
822                         rtp->resp = 0;
823                         rtp->lastevent = seqno;
824                 }
825         }
826
827         rtp->dtmfcount = dtmftimeout;
828         rtp->dtmfsamples = samples;
829
830         return f;
831 }
832
833 /*!
834  * \brief Process Comfort Noise RTP.
835  * 
836  * This is incomplete at the moment.
837  * 
838 */
839 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
840 {
841         struct ast_frame *f = NULL;
842         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
843            totally help us out becuase we don't have an engine to keep it going and we are not
844            guaranteed to have it every 20ms or anything */
845         if (rtpdebug)
846                 ast_debug(0, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
847
848         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
849                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
850                         ast_inet_ntoa(rtp->them.sin_addr));
851                 ast_set_flag(rtp, FLAG_3389_WARNING);
852         }
853         
854         /* Must have at least one byte */
855         if (!len)
856                 return NULL;
857         if (len < 24) {
858                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
859                 rtp->f.datalen = len - 1;
860                 rtp->f.offset = AST_FRIENDLY_OFFSET;
861                 memcpy(rtp->f.data, data + 1, len - 1);
862         } else {
863                 rtp->f.data = NULL;
864                 rtp->f.offset = 0;
865                 rtp->f.datalen = 0;
866         }
867         rtp->f.frametype = AST_FRAME_CNG;
868         rtp->f.subclass = data[0] & 0x7f;
869         rtp->f.datalen = len - 1;
870         rtp->f.samples = 0;
871         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
872         f = &rtp->f;
873         return f;
874 }
875
876 static int rtpread(int *id, int fd, short events, void *cbdata)
877 {
878         struct ast_rtp *rtp = cbdata;
879         struct ast_frame *f;
880         f = ast_rtp_read(rtp);
881         if (f) {
882                 if (rtp->callback)
883                         rtp->callback(rtp, f, rtp->data);
884         }
885         return 1;
886 }
887
888 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
889 {
890         socklen_t len;
891         int position, i, packetwords;
892         int res;
893         struct sockaddr_in sin;
894         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
895         unsigned int *rtcpheader;
896         int pt;
897         struct timeval now;
898         unsigned int length;
899         int rc;
900         double rttsec;
901         uint64_t rtt = 0;
902         unsigned int dlsr;
903         unsigned int lsr;
904         unsigned int msw;
905         unsigned int lsw;
906         unsigned int comp;
907         struct ast_frame *f = &ast_null_frame;
908         
909         if (!rtp || !rtp->rtcp)
910                 return &ast_null_frame;
911
912         len = sizeof(sin);
913         
914         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
915                                         0, (struct sockaddr *)&sin, &len);
916         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
917         
918         if (res < 0) {
919                 if (errno == EBADF)
920                         CRASH;
921                 if (errno != EAGAIN) {
922                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
923                         return NULL;
924                 }
925                 return &ast_null_frame;
926         }
927
928         packetwords = res / 4;
929         
930         if (rtp->nat) {
931                 /* Send to whoever sent to us */
932                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
933                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
934                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
935                         if (option_debug || rtpdebug)
936                                 ast_debug(0, "RTCP NAT: Got RTCP from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
937                 }
938         }
939
940         ast_debug(1, "Got RTCP report of %d bytes\n", res);
941
942         /* Process a compound packet */
943         position = 0;
944         while (position < packetwords) {
945                 i = position;
946                 length = ntohl(rtcpheader[i]);
947                 pt = (length & 0xff0000) >> 16;
948                 rc = (length & 0x1f000000) >> 24;
949                 length &= 0xffff;
950     
951                 if ((i + length) > packetwords) {
952                         ast_log(LOG_WARNING, "RTCP Read too short\n");
953                         return &ast_null_frame;
954                 }
955                 
956                 if (rtcp_debug_test_addr(&sin)) {
957                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
958                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
959                         ast_verbose("Reception reports: %d\n", rc);
960                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
961                 }
962     
963                 i += 2; /* Advance past header and ssrc */
964                 
965                 switch (pt) {
966                 case RTCP_PT_SR:
967                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
968                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
969                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
970                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
971     
972                         if (rtcp_debug_test_addr(&sin)) {
973                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
974                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
975                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
976                         }
977                         i += 5;
978                         if (rc < 1)
979                                 break;
980                         /* Intentional fall through */
981                 case RTCP_PT_RR:
982                         /* Don't handle multiple reception reports (rc > 1) yet */
983                         /* Calculate RTT per RFC */
984                         gettimeofday(&now, NULL);
985                         timeval2ntp(now, &msw, &lsw);
986                         if (ntohl(rtcpheader[i + 4]) && ntohl(rtcpheader[i + 5])) { /* We must have the LSR && DLSR */
987                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
988                                 lsr = ntohl(rtcpheader[i + 4]);
989                                 dlsr = ntohl(rtcpheader[i + 5]);
990                                 rtt = comp - lsr - dlsr;
991
992                                 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
993                                    sess->ee_delay = (eedelay * 1000) / 65536; */
994                                 if (rtt < 4294) {
995                                     rtt = (rtt * 1000000) >> 16;
996                                 } else {
997                                     rtt = (rtt * 1000) >> 16;
998                                     rtt *= 1000;
999                                 }
1000                                 rtt = rtt / 1000.;
1001                                 rttsec = rtt / 1000.;
1002
1003                                 if (comp - dlsr >= lsr) {
1004                                         rtp->rtcp->accumulated_transit += rttsec;
1005                                         rtp->rtcp->rtt = rttsec;
1006                                         if (rtp->rtcp->maxrtt<rttsec)
1007                                                 rtp->rtcp->maxrtt = rttsec;
1008                                         if (rtp->rtcp->minrtt>rttsec)
1009                                                 rtp->rtcp->minrtt = rttsec;
1010                                 } else if (rtcp_debug_test_addr(&sin)) {
1011                                         ast_verbose("Internal RTCP NTP clock skew detected: "
1012                                                            "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
1013                                                            "diff=%d\n",
1014                                                            lsr, comp, dlsr, dlsr / 65536,
1015                                                            (dlsr % 65536) * 1000 / 65536,
1016                                                            dlsr - (comp - lsr));
1017                                 }
1018                         }
1019
1020                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1021                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1022                         if (rtcp_debug_test_addr(&sin)) {
1023                                 ast_verbose("  Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1024                                 ast_verbose("  Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1025                                 ast_verbose("  Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1026                                 ast_verbose("  Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1027                                 ast_verbose("  Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1028                                 ast_verbose("  Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1029                                 ast_verbose("  DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1030                                 if (rtt)
1031                                         ast_verbose("  RTT: %lu(sec)\n", (unsigned long) rtt);
1032                         }
1033                         if (rtt) {
1034                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1035                                                                     "PT: %d(%s)\r\n"
1036                                                                     "ReceptionReports: %d\r\n"
1037                                                                     "SenderSSRC: %u\r\n"
1038                                                                     "FractionLost: %ld\r\n"
1039                                                                     "PacketsLost: %d\r\n"
1040                                                                     "HighestSequence: %ld\r\n"
1041                                                                     "SequenceNumberCycles: %ld\r\n"
1042                                                                     "IAJitter: %u\r\n"
1043                                                                     "LastSR: %lu.%010lu\r\n"
1044                                                                     "DLSR: %4.4f(sec)\r\n"
1045                                                                     "RTT: %llu(sec)\r\n",
1046                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1047                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1048                                                                     rc,
1049                                                                     rtcpheader[i + 1],
1050                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1051                                                                     rtp->rtcp->reported_lost,
1052                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1053                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1054                                                                     rtp->rtcp->reported_jitter,
1055                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16, ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1056                                                                     ntohl(rtcpheader[i + 5])/65536.0,
1057                                                                     (unsigned long long)rtt);
1058                         } else {
1059                                 manager_event(EVENT_FLAG_REPORTING, "RTCPReceived", "From %s:%d\r\n"
1060                                                                     "PT: %d(%s)\r\n"
1061                                                                     "ReceptionReports: %d\r\n"
1062                                                                     "SenderSSRC: %u\r\n"
1063                                                                     "FractionLost: %ld\r\n"
1064                                                                     "PacketsLost: %d\r\n"
1065                                                                     "HighestSequence: %ld\r\n"
1066                                                                     "SequenceNumberCycles: %ld\r\n"
1067                                                                     "IAJitter: %u\r\n"
1068                                                                     "LastSR: %lu.%010lu\r\n"
1069                                                                     "DLSR: %4.4f(sec)\r\n",
1070                                                                     ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port),
1071                                                                     pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown",
1072                                                                     rc,
1073                                                                     rtcpheader[i + 1],
1074                                                                     (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24),
1075                                                                     rtp->rtcp->reported_lost,
1076                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff),
1077                                                                     (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16,
1078                                                                     rtp->rtcp->reported_jitter,
1079                                                                     (unsigned long) ntohl(rtcpheader[i + 4]) >> 16,
1080                                                                     ((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096,
1081                                                                     ntohl(rtcpheader[i + 5])/65536.0);
1082                         }
1083                         break;
1084                 case RTCP_PT_FUR:
1085                         if (rtcp_debug_test_addr(&sin))
1086                                 ast_verbose("Received an RTCP Fast Update Request\n");
1087                         rtp->f.frametype = AST_FRAME_CONTROL;
1088                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1089                         rtp->f.datalen = 0;
1090                         rtp->f.samples = 0;
1091                         rtp->f.mallocd = 0;
1092                         rtp->f.src = "RTP";
1093                         f = &rtp->f;
1094                         break;
1095                 case RTCP_PT_SDES:
1096                         if (rtcp_debug_test_addr(&sin))
1097                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1098                         break;
1099                 case RTCP_PT_BYE:
1100                         if (rtcp_debug_test_addr(&sin))
1101                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1102                         break;
1103                 default:
1104                         ast_debug(1, "Unknown RTCP packet (pt=%d) received from %s:%d\n", pt, ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1105                         break;
1106                 }
1107                 position += (length + 1);
1108         }
1109                         
1110         return f;
1111 }
1112
1113 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1114 {
1115         struct timeval now;
1116         double transit;
1117         double current_time;
1118         double d;
1119         double dtv;
1120         double prog;
1121         
1122         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1123                 gettimeofday(&rtp->rxcore, NULL);
1124                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1125                 /* map timestamp to a real time */
1126                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1127                 rtp->rxcore.tv_sec -= timestamp / 8000;
1128                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1129                 /* Round to 0.1ms for nice, pretty timestamps */
1130                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1131                 if (rtp->rxcore.tv_usec < 0) {
1132                         /* Adjust appropriately if necessary */
1133                         rtp->rxcore.tv_usec += 1000000;
1134                         rtp->rxcore.tv_sec -= 1;
1135                 }
1136         }
1137
1138         gettimeofday(&now,NULL);
1139         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1140         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1141         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1142         if (tv->tv_usec >= 1000000) {
1143                 tv->tv_usec -= 1000000;
1144                 tv->tv_sec += 1;
1145         }
1146         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1147         dtv = (double)rtp->drxcore + (double)(prog);
1148         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1149         transit = current_time - dtv;
1150         d = transit - rtp->rxtransit;
1151         rtp->rxtransit = transit;
1152         if (d<0)
1153                 d=-d;
1154         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1155         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1156                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1157         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1158                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1159 }
1160
1161 /*! \brief Perform a Packet2Packet RTP write */
1162 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1163 {
1164         int res = 0, payload = 0, bridged_payload = 0, mark;
1165         struct rtpPayloadType rtpPT;
1166         int reconstruct = ntohl(rtpheader[0]);
1167
1168         /* Get fields from packet */
1169         payload = (reconstruct & 0x7f0000) >> 16;
1170         mark = (((reconstruct & 0x800000) >> 23) != 0);
1171
1172         /* Check what the payload value should be */
1173         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1174
1175         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1176         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1177                 return -1;
1178
1179         /* Otherwise adjust bridged payload to match */
1180         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1181
1182         /* If the mark bit has not been sent yet... do it now */
1183         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1184                 mark = 1;
1185                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1186         }
1187
1188         /* Reconstruct part of the packet */
1189         reconstruct &= 0xFF80FFFF;
1190         reconstruct |= (bridged_payload << 16);
1191         reconstruct |= (mark << 23);
1192         rtpheader[0] = htonl(reconstruct);
1193
1194         /* Send the packet back out */
1195         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1196         if (res < 0) {
1197                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1198                         ast_debug(1, "RTP Transmission error of packet to %s:%d: %s\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), strerror(errno));
1199                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1200                         if (option_debug || rtpdebug)
1201                                 ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port));
1202                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1203                 }
1204                 return 0;
1205         } else if (rtp_debug_test_addr(&bridged->them))
1206                         ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged->them.sin_addr), ntohs(bridged->them.sin_port), bridged_payload, len - hdrlen);
1207
1208         return 0;
1209 }
1210
1211 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1212 {
1213         int res;
1214         struct sockaddr_in sin;
1215         socklen_t len;
1216         unsigned int seqno;
1217         int version;
1218         int payloadtype;
1219         int hdrlen = 12;
1220         int padding;
1221         int mark;
1222         int ext;
1223         int cc;
1224         unsigned int ssrc;
1225         unsigned int timestamp;
1226         unsigned int *rtpheader;
1227         struct rtpPayloadType rtpPT;
1228         struct ast_rtp *bridged = NULL;
1229         
1230         /* If time is up, kill it */
1231         if (rtp->sending_digit)
1232                 ast_rtp_senddigit_continuation(rtp);
1233
1234         len = sizeof(sin);
1235         
1236         /* Cache where the header will go */
1237         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1238                                         0, (struct sockaddr *)&sin, &len);
1239
1240         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1241         if (res < 0) {
1242                 if (errno == EBADF)
1243                         CRASH;
1244                 if (errno != EAGAIN) {
1245                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
1246                         return NULL;
1247                 }
1248                 return &ast_null_frame;
1249         }
1250         
1251         if (res < hdrlen) {
1252                 ast_log(LOG_WARNING, "RTP Read too short\n");
1253                 return &ast_null_frame;
1254         }
1255
1256         /* Get fields */
1257         seqno = ntohl(rtpheader[0]);
1258
1259         /* Check RTP version */
1260         version = (seqno & 0xC0000000) >> 30;
1261         if (!version) {
1262                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
1263                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1264                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1265                 }
1266                 return &ast_null_frame;
1267         }
1268
1269 #if 0   /* Allow to receive RTP stream with closed transmission path */
1270         /* If we don't have the other side's address, then ignore this */
1271         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1272                 return &ast_null_frame;
1273 #endif
1274
1275         /* Send to whoever send to us if NAT is turned on */
1276         if (rtp->nat) {
1277                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1278                     (rtp->them.sin_port != sin.sin_port)) {
1279                         rtp->them = sin;
1280                         if (rtp->rtcp) {
1281                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1282                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1283                         }
1284                         rtp->rxseqno = 0;
1285                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1286                         if (option_debug || rtpdebug)
1287                                 ast_debug(0, "RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
1288                 }
1289         }
1290
1291         /* If we are bridged to another RTP stream, send direct */
1292         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1293                 return &ast_null_frame;
1294
1295         if (version != 2)
1296                 return &ast_null_frame;
1297
1298         payloadtype = (seqno & 0x7f0000) >> 16;
1299         padding = seqno & (1 << 29);
1300         mark = seqno & (1 << 23);
1301         ext = seqno & (1 << 28);
1302         cc = (seqno & 0xF000000) >> 24;
1303         seqno &= 0xffff;
1304         timestamp = ntohl(rtpheader[1]);
1305         ssrc = ntohl(rtpheader[2]);
1306         
1307         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1308                 if (option_debug || rtpdebug)
1309                         ast_debug(0, "Forcing Marker bit, because SSRC has changed\n");
1310                 mark = 1;
1311         }
1312
1313         rtp->rxssrc = ssrc;
1314         
1315         if (padding) {
1316                 /* Remove padding bytes */
1317                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1318         }
1319         
1320         if (cc) {
1321                 /* CSRC fields present */
1322                 hdrlen += cc*4;
1323         }
1324
1325         if (ext) {
1326                 /* RTP Extension present */
1327                 hdrlen += (ntohl(rtpheader[hdrlen/4]) & 0xffff) << 2;
1328                 hdrlen += 4;
1329                 if (option_debug) {
1330                         int profile;
1331                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1332                         if (profile == 0x505a)
1333                                 ast_debug(1, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1334                         else
1335                                 ast_debug(1, "Found unknown RTP Extensions %x\n", profile);
1336                 }
1337         }
1338
1339         if (res < hdrlen) {
1340                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1341                 return &ast_null_frame;
1342         }
1343
1344         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1345
1346         if (rtp->rxcount==1) {
1347                 /* This is the first RTP packet successfully received from source */
1348                 rtp->seedrxseqno = seqno;
1349         }
1350
1351         /* Do not schedule RR if RTCP isn't run */
1352         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1353                 /* Schedule transmission of Receiver Report */
1354                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1355         }
1356         if ( (int)rtp->lastrxseqno - (int)seqno  > 100) /* if so it would indicate that the sender cycled; allow for misordering */
1357                 rtp->cycles += RTP_SEQ_MOD;
1358
1359         rtp->lastrxseqno = seqno;
1360         
1361         if (rtp->themssrc==0)
1362                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1363         
1364         if (rtp_debug_test_addr(&sin))
1365                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1366                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1367
1368         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1369         if (!rtpPT.isAstFormat) {
1370                 struct ast_frame *f = NULL;
1371
1372                 /* This is special in-band data that's not one of our codecs */
1373                 if (rtpPT.code == AST_RTP_DTMF) {
1374                         /* It's special -- rfc2833 process it */
1375                         if (rtp_debug_test_addr(&sin)) {
1376                                 unsigned char *data;
1377                                 unsigned int event;
1378                                 unsigned int event_end;
1379                                 unsigned int duration;
1380                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1381                                 event = ntohl(*((unsigned int *)(data)));
1382                                 event >>= 24;
1383                                 event_end = ntohl(*((unsigned int *)(data)));
1384                                 event_end <<= 8;
1385                                 event_end >>= 24;
1386                                 duration = ntohl(*((unsigned int *)(data)));
1387                                 duration &= 0xFFFF;
1388                                 ast_verbose("Got  RTP RFC2833 from   %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u, mark %d, event %08x, end %d, duration %-5.5d) \n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp, res - hdrlen, (mark?1:0), event, ((event_end & 0x80)?1:0), duration);
1389                         }
1390                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1391                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1392                         /* It's really special -- process it the Cisco way */
1393                         if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1394                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1395                                 rtp->lastevent = seqno;
1396                         }
1397                 } else if (rtpPT.code == AST_RTP_CN) {
1398                         /* Comfort Noise */
1399                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1400                 } else {
1401                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1402                 }
1403                 return f ? f : &ast_null_frame;
1404         }
1405         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1406         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : (rtp->f.subclass < AST_FORMAT_MAX_VIDEO) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
1407
1408         if (!rtp->lastrxts)
1409                 rtp->lastrxts = timestamp;
1410
1411         rtp->rxseqno = seqno;
1412
1413         /* Record received timestamp as last received now */
1414         rtp->lastrxts = timestamp;
1415
1416         rtp->f.mallocd = 0;
1417         rtp->f.datalen = res - hdrlen;
1418         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1419         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1420         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1421                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1422                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1423                         ast_frame_byteswap_be(&rtp->f);
1424                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1425                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1426                 rtp->f.has_timing_info = 1;
1427                 rtp->f.ts = timestamp / 8;
1428                 rtp->f.len = rtp->f.samples / 8;
1429                 rtp->f.seqno = seqno;
1430         } else if(rtp->f.subclass < AST_FORMAT_MAX_VIDEO) {
1431                 /* Video -- samples is # of samples vs. 90000 */
1432                 if (!rtp->lastividtimestamp)
1433                         rtp->lastividtimestamp = timestamp;
1434                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1435                 rtp->lastividtimestamp = timestamp;
1436                 rtp->f.delivery.tv_sec = 0;
1437                 rtp->f.delivery.tv_usec = 0;
1438                 if (mark)
1439                         rtp->f.subclass |= 0x1;
1440         } else {
1441                 /* TEXT -- samples is # of samples vs. 1000 */
1442                 if (!rtp->lastitexttimestamp)
1443                         rtp->lastitexttimestamp = timestamp;
1444                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
1445                 rtp->lastitexttimestamp = timestamp;
1446                 rtp->f.delivery.tv_sec = 0;
1447                 rtp->f.delivery.tv_usec = 0;
1448         }
1449         rtp->f.src = "RTP";
1450         return &rtp->f;
1451 }
1452
1453 /* The following array defines the MIME Media type (and subtype) for each
1454    of our codecs, or RTP-specific data type. */
1455 static struct {
1456         struct rtpPayloadType payloadType;
1457         char* type;
1458         char* subtype;
1459 } mimeTypes[] = {
1460         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1461         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1462         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1463         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1464         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1465         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1466         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1467         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1468         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1469         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1470         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1471         {{1, AST_FORMAT_G722}, "audio", "G722"},
1472         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1473         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1474         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1475         {{0, AST_RTP_CN}, "audio", "CN"},
1476         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1477         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1478         {{1, AST_FORMAT_H261}, "video", "H261"},
1479         {{1, AST_FORMAT_H263}, "video", "H263"},
1480         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1481         {{1, AST_FORMAT_H264}, "video", "H264"},
1482         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES"},
1483         {{1, AST_FORMAT_T140}, "text", "T140"},
1484 };
1485
1486 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1487    also, our own choices for dynamic payload types.  This is our master
1488    table for transmission */
1489 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1490         [0] = {1, AST_FORMAT_ULAW},
1491 #ifdef USE_DEPRECATED_G726
1492         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1493 #endif
1494         [3] = {1, AST_FORMAT_GSM},
1495         [4] = {1, AST_FORMAT_G723_1},
1496         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1497         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1498         [7] = {1, AST_FORMAT_LPC10},
1499         [8] = {1, AST_FORMAT_ALAW},
1500         [9] = {1, AST_FORMAT_G722},
1501         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1502         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1503         [13] = {0, AST_RTP_CN},
1504         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1505         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1506         [18] = {1, AST_FORMAT_G729A},
1507         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1508         [26] = {1, AST_FORMAT_JPEG},
1509         [31] = {1, AST_FORMAT_H261},
1510         [34] = {1, AST_FORMAT_H263},
1511         [97] = {1, AST_FORMAT_ILBC},
1512         [99] = {1, AST_FORMAT_H264},
1513         [101] = {0, AST_RTP_DTMF},
1514         [102] = {1, AST_FORMAT_T140},   /* Real time text chat */
1515         [103] = {1, AST_FORMAT_H263_PLUS},
1516         [104] = {1, AST_FORMAT_MP4_VIDEO},
1517         [110] = {1, AST_FORMAT_SPEEX},
1518         [111] = {1, AST_FORMAT_G726},
1519         [112] = {1, AST_FORMAT_G726_AAL2},
1520         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1521 };
1522
1523 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1524 {
1525         int i;
1526
1527         if (!rtp)
1528                 return;
1529
1530         rtp_bridge_lock(rtp);
1531
1532         for (i = 0; i < MAX_RTP_PT; ++i) {
1533                 rtp->current_RTP_PT[i].isAstFormat = 0;
1534                 rtp->current_RTP_PT[i].code = 0;
1535         }
1536
1537         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1538         rtp->rtp_lookup_code_cache_code = 0;
1539         rtp->rtp_lookup_code_cache_result = 0;
1540
1541         rtp_bridge_unlock(rtp);
1542 }
1543
1544 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1545 {
1546         int i;
1547
1548         rtp_bridge_lock(rtp);
1549
1550         /* Initialize to default payload types */
1551         for (i = 0; i < MAX_RTP_PT; ++i) {
1552                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1553                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1554         }
1555
1556         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1557         rtp->rtp_lookup_code_cache_code = 0;
1558         rtp->rtp_lookup_code_cache_result = 0;
1559
1560         rtp_bridge_unlock(rtp);
1561 }
1562
1563 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1564 {
1565         unsigned int i;
1566
1567         rtp_bridge_lock(dest);
1568         rtp_bridge_lock(src);
1569
1570         for (i=0; i < MAX_RTP_PT; ++i) {
1571                 dest->current_RTP_PT[i].isAstFormat = 
1572                         src->current_RTP_PT[i].isAstFormat;
1573                 dest->current_RTP_PT[i].code = 
1574                         src->current_RTP_PT[i].code; 
1575         }
1576         dest->rtp_lookup_code_cache_isAstFormat = 0;
1577         dest->rtp_lookup_code_cache_code = 0;
1578         dest->rtp_lookup_code_cache_result = 0;
1579
1580         rtp_bridge_unlock(src);
1581         rtp_bridge_unlock(dest);
1582 }
1583
1584 /*! \brief Get channel driver interface structure */
1585 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1586 {
1587         struct ast_rtp_protocol *cur = NULL;
1588
1589         AST_RWLIST_RDLOCK(&protos);
1590         AST_RWLIST_TRAVERSE(&protos, cur, list) {
1591                 if (cur->type == chan->tech->type)
1592                         break;
1593         }
1594         AST_RWLIST_UNLOCK(&protos);
1595
1596         return cur;
1597 }
1598
1599 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1600 {
1601         // dest = c0, src = c1
1602         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1603         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1604         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1605         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1606         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED, text_dest_res = AST_RTP_GET_FAILED;
1607         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED, text_src_res = AST_RTP_GET_FAILED;
1608         int srccodec, destcodec, nat_active = 0;
1609
1610         /* Lock channels */
1611         ast_channel_lock(c0);
1612         if (c1) {
1613                 while (ast_channel_trylock(c1)) {
1614                         ast_channel_unlock(c0);
1615                         usleep(1);
1616                         ast_channel_lock(c0);
1617                 }
1618         }
1619
1620         /* Find channel driver interfaces */
1621         destpr = get_proto(c0);
1622         if (c1)
1623                 srcpr = get_proto(c1);
1624         if (!destpr) {
1625                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1626                 ast_channel_unlock(c0);
1627                 if (c1)
1628                         ast_channel_unlock(c1);
1629                 return -1;
1630         }
1631         if (!srcpr) {
1632                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1633                 ast_channel_unlock(c0);
1634                 if (c1)
1635                         ast_channel_unlock(c1);
1636                 return -1;
1637         }
1638
1639         /* Get audio, video  and text interface (if native bridge is possible) */
1640         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1641         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1642         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
1643         if (srcpr) {
1644                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1645                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1646                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
1647         }
1648
1649         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1650         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1651                 /* Somebody doesn't want to play... */
1652                 ast_channel_unlock(c0);
1653                 if (c1)
1654                         ast_channel_unlock(c1);
1655                 return -1;
1656         }
1657         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1658                 srccodec = srcpr->get_codec(c1);
1659         else
1660                 srccodec = 0;
1661         if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1662                 destcodec = destpr->get_codec(c0);
1663         else
1664                 destcodec = 0;
1665         /* Ensure we have at least one matching codec */
1666         if (!(srccodec & destcodec)) {
1667                 ast_channel_unlock(c0);
1668                 if (c1)
1669                         ast_channel_unlock(c1);
1670                 return 0;
1671         }
1672         /* Consider empty media as non-existant */
1673         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1674                 srcp = NULL;
1675         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1676                 nat_active = 1;
1677         /* Bridge media early */
1678         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
1679                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1680         ast_channel_unlock(c0);
1681         if (c1)
1682                 ast_channel_unlock(c1);
1683         ast_debug(1, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1684         return 0;
1685 }
1686
1687 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1688 {
1689         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1690         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1691         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1692         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1693         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED, text_dest_res = AST_RTP_GET_FAILED;
1694         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED, text_src_res = AST_RTP_GET_FAILED; 
1695         int srccodec, destcodec;
1696
1697         /* Lock channels */
1698         ast_channel_lock(dest);
1699         while (ast_channel_trylock(src)) {
1700                 ast_channel_unlock(dest);
1701                 usleep(1);
1702                 ast_channel_lock(dest);
1703         }
1704
1705         /* Find channel driver interfaces */
1706         if (!(destpr = get_proto(dest))) {
1707                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1708                 ast_channel_unlock(dest);
1709                 ast_channel_unlock(src);
1710                 return 0;
1711         }
1712         if (!(srcpr = get_proto(src))) {
1713                 ast_debug(1, "Channel '%s' has no RTP, not doing anything\n", src->name);
1714                 ast_channel_unlock(dest);
1715                 ast_channel_unlock(src);
1716                 return 0;
1717         }
1718
1719         /* Get audio and video interface (if native bridge is possible) */
1720         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1721         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1722         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
1723         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1724         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1725         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
1726
1727         /* Ensure we have at least one matching codec */
1728         if (srcpr->get_codec)
1729                 srccodec = srcpr->get_codec(src);
1730         else
1731                 srccodec = 0;
1732         if (destpr->get_codec)
1733                 destcodec = destpr->get_codec(dest);
1734         else
1735                 destcodec = 0;
1736
1737         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1738         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1739                 /* Somebody doesn't want to play... */
1740                 ast_channel_unlock(dest);
1741                 ast_channel_unlock(src);
1742                 return 0;
1743         }
1744         ast_rtp_pt_copy(destp, srcp);
1745         if (vdestp && vsrcp)
1746                 ast_rtp_pt_copy(vdestp, vsrcp);
1747         if (tdestp && tsrcp)
1748                 ast_rtp_pt_copy(tdestp, tsrcp);
1749         if (media) {
1750                 /* Bridge early */
1751                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1752                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1753         }
1754         ast_channel_unlock(dest);
1755         ast_channel_unlock(src);
1756         ast_debug(1, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1757         return 1;
1758 }
1759
1760 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1761  * By default, use the well-known value for this type (although it may 
1762  * still be set to a different value by a subsequent "a=rtpmap:" line)
1763  */
1764 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1765 {
1766         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1767                 return; /* bogus payload type */
1768
1769         rtp_bridge_lock(rtp);
1770         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1771         rtp_bridge_unlock(rtp);
1772
1773
1774 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1775  * an SDP "a=rtpmap:" line.
1776  */
1777 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1778                              char *mimeType, char *mimeSubtype,
1779                              enum ast_rtp_options options)
1780 {
1781         unsigned int i;
1782
1783         if (pt < 0 || pt > MAX_RTP_PT) 
1784                 return; /* bogus payload type */
1785         
1786         rtp_bridge_lock(rtp);
1787
1788         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1789                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1790                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1791                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1792                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1793                             mimeTypes[i].payloadType.isAstFormat &&
1794                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1795                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1796                         break;
1797                 }
1798         }
1799
1800         rtp_bridge_unlock(rtp);
1801
1802         return;
1803
1804
1805 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1806  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1807 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1808                                  int* astFormats, int* nonAstFormats)
1809 {
1810         int pt;
1811         
1812         rtp_bridge_lock(rtp);
1813         
1814         *astFormats = *nonAstFormats = 0;
1815         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1816                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1817                         *astFormats |= rtp->current_RTP_PT[pt].code;
1818                 } else {
1819                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1820                 }
1821         }
1822
1823         rtp_bridge_unlock(rtp);
1824         
1825         return;
1826 }
1827
1828 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1829 {
1830         struct rtpPayloadType result;
1831
1832         result.isAstFormat = result.code = 0;
1833
1834         if (pt < 0 || pt > MAX_RTP_PT) 
1835                 return result; /* bogus payload type */
1836
1837         /* Start with negotiated codecs */
1838         rtp_bridge_lock(rtp);
1839         result = rtp->current_RTP_PT[pt];
1840         rtp_bridge_unlock(rtp);
1841
1842         /* If it doesn't exist, check our static RTP type list, just in case */
1843         if (!result.code) 
1844                 result = static_RTP_PT[pt];
1845
1846         return result;
1847 }
1848
1849 /*! \brief Looks up an RTP code out of our *static* outbound list */
1850 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
1851 {
1852         int pt = 0;
1853
1854         rtp_bridge_lock(rtp);
1855
1856         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1857                 code == rtp->rtp_lookup_code_cache_code) {
1858                 /* Use our cached mapping, to avoid the overhead of the loop below */
1859                 pt = rtp->rtp_lookup_code_cache_result;
1860                 rtp_bridge_unlock(rtp);
1861                 return pt;
1862         }
1863
1864         /* Check the dynamic list first */
1865         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1866                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1867                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1868                         rtp->rtp_lookup_code_cache_code = code;
1869                         rtp->rtp_lookup_code_cache_result = pt;
1870                         rtp_bridge_unlock(rtp);
1871                         return pt;
1872                 }
1873         }
1874
1875         /* Then the static list */
1876         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1877                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1878                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1879                         rtp->rtp_lookup_code_cache_code = code;
1880                         rtp->rtp_lookup_code_cache_result = pt;
1881                         rtp_bridge_unlock(rtp);
1882                         return pt;
1883                 }
1884         }
1885
1886         rtp_bridge_unlock(rtp);
1887
1888         return -1;
1889 }
1890
1891 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1892                                   enum ast_rtp_options options)
1893 {
1894         unsigned int i;
1895
1896         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1897                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1898                         if (isAstFormat &&
1899                             (code == AST_FORMAT_G726_AAL2) &&
1900                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1901                                 return "G726-32";
1902                         else
1903                                 return mimeTypes[i].subtype;
1904                 }
1905         }
1906
1907         return "";
1908 }
1909
1910 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1911                                    const int isAstFormat, enum ast_rtp_options options)
1912 {
1913         int format;
1914         unsigned len;
1915         char *end = buf;
1916         char *start = buf;
1917
1918         if (!buf || !size)
1919                 return NULL;
1920
1921         snprintf(end, size, "0x%x (", capability);
1922
1923         len = strlen(end);
1924         end += len;
1925         size -= len;
1926         start = end;
1927
1928         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1929                 if (capability & format) {
1930                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1931
1932                         snprintf(end, size, "%s|", name);
1933                         len = strlen(end);
1934                         end += len;
1935                         size -= len;
1936                 }
1937         }
1938
1939         if (start == end)
1940                 snprintf(start, size, "nothing)"); 
1941         else if (size > 1)
1942                 *(end -1) = ')';
1943         
1944         return buf;
1945 }
1946
1947 /*! \brief Open RTP or RTCP socket for a session */
1948 static int rtp_socket(void)
1949 {
1950         int s;
1951         long flags;
1952         s = socket(AF_INET, SOCK_DGRAM, 0);
1953         if (s > -1) {
1954                 flags = fcntl(s, F_GETFL);
1955                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1956 #ifdef SO_NO_CHECK
1957                 if (nochecksums)
1958                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1959 #endif
1960         }
1961         return s;
1962 }
1963
1964 /*!
1965  * \brief Initialize a new RTCP session.
1966  * 
1967  * \returns The newly initialized RTCP session.
1968  */
1969 static struct ast_rtcp *ast_rtcp_new(void)
1970 {
1971         struct ast_rtcp *rtcp;
1972
1973         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1974                 return NULL;
1975         rtcp->s = rtp_socket();
1976         rtcp->us.sin_family = AF_INET;
1977         rtcp->them.sin_family = AF_INET;
1978
1979         if (rtcp->s < 0) {
1980                 ast_free(rtcp);
1981                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1982                 return NULL;
1983         }
1984
1985         return rtcp;
1986 }
1987
1988 /*!
1989  * \brief Initialize a new RTP structure.
1990  *
1991  */
1992 void ast_rtp_new_init(struct ast_rtp *rtp)
1993 {
1994 #ifdef P2P_INTENSE
1995         ast_mutex_init(&rtp->bridge_lock);
1996 #endif
1997
1998         rtp->them.sin_family = AF_INET;
1999         rtp->us.sin_family = AF_INET;
2000         rtp->ssrc = ast_random();
2001         rtp->seqno = ast_random() & 0xffff;
2002         ast_set_flag(rtp, FLAG_HAS_DTMF);
2003
2004         return;
2005 }
2006
2007 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2008 {
2009         struct ast_rtp *rtp;
2010         int x;
2011         int first;
2012         int startplace;
2013         
2014         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2015                 return NULL;
2016
2017         ast_rtp_new_init(rtp);
2018
2019         rtp->s = rtp_socket();
2020         if (rtp->s < 0) {
2021                 ast_free(rtp);
2022                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
2023                 return NULL;
2024         }
2025         if (sched && rtcpenable) {
2026                 rtp->sched = sched;
2027                 rtp->rtcp = ast_rtcp_new();
2028         }
2029         
2030         /* Select a random port number in the range of possible RTP */
2031         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
2032         x = x & ~1;
2033         /* Save it for future references. */
2034         startplace = x;
2035         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
2036         for (;;) {
2037                 /* Must be an even port number by RTP spec */
2038                 rtp->us.sin_port = htons(x);
2039                 rtp->us.sin_addr = addr;
2040
2041                 /* If there's rtcp, initialize it as well. */
2042                 if (rtp->rtcp) {
2043                         rtp->rtcp->us.sin_port = htons(x + 1);
2044                         rtp->rtcp->us.sin_addr = addr;
2045                 }
2046                 /* Try to bind it/them. */
2047                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
2048                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
2049                         break;
2050                 if (!first) {
2051                         /* Primary bind succeeded! Gotta recreate it */
2052                         close(rtp->s);
2053                         rtp->s = rtp_socket();
2054                 }
2055                 if (errno != EADDRINUSE) {
2056                         /* We got an error that wasn't expected, abort! */
2057                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2058                         close(rtp->s);
2059                         if (rtp->rtcp) {
2060                                 close(rtp->rtcp->s);
2061                                 ast_free(rtp->rtcp);
2062                         }
2063                         ast_free(rtp);
2064                         return NULL;
2065                 }
2066                 /* The port was used, increment it (by two). */
2067                 x += 2;
2068                 /* Did we go over the limit ? */
2069                 if (x > rtpend)
2070                         /* then, start from the begingig. */
2071                         x = (rtpstart + 1) & ~1;
2072                 /* Check if we reached the place were we started. */
2073                 if (x == startplace) {
2074                         /* If so, there's no ports available. */
2075                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2076                         close(rtp->s);
2077                         if (rtp->rtcp) {
2078                                 close(rtp->rtcp->s);
2079                                 ast_free(rtp->rtcp);
2080                         }
2081                         ast_free(rtp);
2082                         return NULL;
2083                 }
2084         }
2085         rtp->sched = sched;
2086         rtp->io = io;
2087         if (callbackmode) {
2088                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2089                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2090         }
2091         ast_rtp_pt_default(rtp);
2092         return rtp;
2093 }
2094
2095 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2096 {
2097         struct in_addr ia;
2098
2099         memset(&ia, 0, sizeof(ia));
2100         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2101 }
2102
2103 int ast_rtp_setqos(struct ast_rtp *rtp, int tos, int cos)
2104 {
2105         return ast_netsock_set_qos(rtp->s, tos, cos);
2106 }
2107
2108 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2109 {
2110         rtp->them.sin_port = them->sin_port;
2111         rtp->them.sin_addr = them->sin_addr;
2112         if (rtp->rtcp) {
2113                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2114                 rtp->rtcp->them.sin_addr = them->sin_addr;
2115         }
2116         rtp->rxseqno = 0;
2117 }
2118
2119 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2120 {
2121         if ((them->sin_family != AF_INET) ||
2122                 (them->sin_port != rtp->them.sin_port) ||
2123                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2124                 them->sin_family = AF_INET;
2125                 them->sin_port = rtp->them.sin_port;
2126                 them->sin_addr = rtp->them.sin_addr;
2127                 return 1;
2128         }
2129         return 0;
2130 }
2131
2132 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2133 {
2134         *us = rtp->us;
2135 }
2136
2137 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2138 {
2139         struct ast_rtp *bridged = NULL;
2140
2141         rtp_bridge_lock(rtp);
2142         bridged = rtp->bridged;
2143         rtp_bridge_unlock(rtp);
2144
2145         return bridged;
2146 }
2147
2148 void ast_rtp_stop(struct ast_rtp *rtp)
2149 {
2150         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2151                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2152                 rtp->rtcp->schedid = -1;
2153         }
2154
2155         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2156         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2157         if (rtp->rtcp) {
2158                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2159                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2160         }
2161         
2162         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2163 }
2164
2165 void ast_rtp_reset(struct ast_rtp *rtp)
2166 {
2167         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2168         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2169         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2170         rtp->lastts = 0;
2171         rtp->lastdigitts = 0;
2172         rtp->lastrxts = 0;
2173         rtp->lastividtimestamp = 0;
2174         rtp->lastovidtimestamp = 0;
2175         rtp->lastitexttimestamp = 0;
2176         rtp->lastotexttimestamp = 0;
2177         rtp->lasteventseqn = 0;
2178         rtp->lastevent = 0;
2179         rtp->lasttxformat = 0;
2180         rtp->lastrxformat = 0;
2181         rtp->dtmfcount = 0;
2182         rtp->dtmfsamples = 0;
2183         rtp->seqno = 0;
2184         rtp->rxseqno = 0;
2185 }
2186
2187 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2188 {
2189         /*
2190         *ssrc          our ssrc
2191         *themssrc      their ssrc
2192         *lp            lost packets
2193         *rxjitter      our calculated jitter(rx)
2194         *rxcount       no. received packets
2195         *txjitter      reported jitter of the other end
2196         *txcount       transmitted packets
2197         *rlp           remote lost packets
2198         *rtt           round trip time
2199         */
2200
2201         if (qual) {
2202                 qual->local_ssrc = rtp->ssrc;
2203                 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2204                 qual->local_jitter = rtp->rxjitter;
2205                 qual->local_count = rtp->rxcount;
2206                 qual->remote_ssrc = rtp->themssrc;
2207                 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2208                 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2209                 qual->remote_count = rtp->txcount;
2210                 qual->rtt = rtp->rtcp->rtt;
2211         }
2212         snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt);
2213         
2214         return rtp->rtcp->quality;
2215 }
2216
2217 void ast_rtp_destroy(struct ast_rtp *rtp)
2218 {
2219         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2220                 /*Print some info on the call here */
2221                 ast_verbose("  RTP-stats\n");
2222                 ast_verbose("* Our Receiver:\n");
2223                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2224                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2225                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2226                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2227                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2228                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2229                 ast_verbose("* Our Sender:\n");
2230                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2231                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2232                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2233                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2234                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2235                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2236         }
2237
2238         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2239                                             "ReceivedPackets: %u\r\n"
2240                                             "LostPackets: %u\r\n"
2241                                             "Jitter: %.4f\r\n"
2242                                             "Transit: %.4f\r\n"
2243                                             "RRCount: %u\r\n",
2244                                             rtp->themssrc,
2245                                             rtp->rxcount,
2246                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2247                                             rtp->rxjitter,
2248                                             rtp->rxtransit,
2249                                             rtp->rtcp->rr_count);
2250         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2251                                             "SentPackets: %u\r\n"
2252                                             "LostPackets: %u\r\n"
2253                                             "Jitter: %u\r\n"
2254                                             "SRCount: %u\r\n"
2255                                             "RTT: %f\r\n",
2256                                             rtp->ssrc,
2257                                             rtp->txcount,
2258                                             rtp->rtcp->reported_lost,
2259                                             rtp->rtcp->reported_jitter,
2260                                             rtp->rtcp->sr_count,
2261                                             rtp->rtcp->rtt);
2262         if (rtp->smoother)
2263                 ast_smoother_free(rtp->smoother);
2264         if (rtp->ioid)
2265                 ast_io_remove(rtp->io, rtp->ioid);
2266         if (rtp->s > -1)
2267                 close(rtp->s);
2268         if (rtp->rtcp) {
2269                 if (rtp->rtcp->schedid > 0)
2270                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2271                 close(rtp->rtcp->s);
2272                 ast_free(rtp->rtcp);
2273                 rtp->rtcp=NULL;
2274         }
2275 #ifdef P2P_INTENSE
2276         ast_mutex_destroy(&rtp->bridge_lock);
2277 #endif
2278         ast_free(rtp);
2279 }
2280
2281 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2282 {
2283         struct timeval t;
2284         long ms;
2285         if (ast_tvzero(rtp->txcore)) {
2286                 rtp->txcore = ast_tvnow();
2287                 /* Round to 20ms for nice, pretty timestamps */
2288                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2289         }
2290         /* Use previous txcore if available */
2291         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2292         ms = ast_tvdiff_ms(t, rtp->txcore);
2293         if (ms < 0)
2294                 ms = 0;
2295         /* Use what we just got for next time */
2296         rtp->txcore = t;
2297         return (unsigned int) ms;
2298 }
2299
2300 /*! \brief Send begin frames for DTMF */
2301 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2302 {
2303         unsigned int *rtpheader;
2304         int hdrlen = 12, res = 0, i = 0, payload = 0;
2305         char data[256];
2306
2307         if ((digit <= '9') && (digit >= '0'))
2308                 digit -= '0';
2309         else if (digit == '*')
2310                 digit = 10;
2311         else if (digit == '#')
2312                 digit = 11;
2313         else if ((digit >= 'A') && (digit <= 'D'))
2314                 digit = digit - 'A' + 12;
2315         else if ((digit >= 'a') && (digit <= 'd'))
2316                 digit = digit - 'a' + 12;
2317         else {
2318                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2319                 return 0;
2320         }
2321
2322         /* If we have no peer, return immediately */    
2323         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2324                 return 0;
2325
2326         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2327
2328         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2329         rtp->send_duration = 160;
2330         
2331         /* Get a pointer to the header */
2332         rtpheader = (unsigned int *)data;
2333         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2334         rtpheader[1] = htonl(rtp->lastdigitts);
2335         rtpheader[2] = htonl(rtp->ssrc); 
2336
2337         for (i = 0; i < 2; i++) {
2338                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2339                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2340                 if (res < 0) 
2341                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2342                                 ast_inet_ntoa(rtp->them.sin_addr),
2343                                 ntohs(rtp->them.sin_port), strerror(errno));
2344                 if (rtp_debug_test_addr(&rtp->them))
2345                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2346                                     ast_inet_ntoa(rtp->them.sin_addr),
2347                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2348                 /* Increment sequence number */
2349                 rtp->seqno++;
2350                 /* Increment duration */
2351                 rtp->send_duration += 160;
2352                 /* Clear marker bit and set seqno */
2353                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2354         }
2355
2356         /* Since we received a begin, we can safely store the digit and disable any compensation */
2357         rtp->sending_digit = 1;
2358         rtp->send_digit = digit;
2359         rtp->send_payload = payload;
2360
2361         return 0;
2362 }
2363
2364 /*! \brief Send continuation frame for DTMF */
2365 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2366 {
2367         unsigned int *rtpheader;
2368         int hdrlen = 12, res = 0;
2369         char data[256];
2370
2371         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2372                 return 0;
2373
2374         /* Setup packet to send */
2375         rtpheader = (unsigned int *)data;
2376         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2377         rtpheader[1] = htonl(rtp->lastdigitts);
2378         rtpheader[2] = htonl(rtp->ssrc);
2379         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2380         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2381         
2382         /* Transmit */
2383         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2384         if (res < 0)
2385                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2386                         ast_inet_ntoa(rtp->them.sin_addr),
2387                         ntohs(rtp->them.sin_port), strerror(errno));
2388         if (rtp_debug_test_addr(&rtp->them))
2389                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2390                             ast_inet_ntoa(rtp->them.sin_addr),
2391                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2392
2393         /* Increment sequence number */
2394         rtp->seqno++;
2395         /* Increment duration */
2396         rtp->send_duration += 160;
2397
2398         return 0;
2399 }
2400
2401 /*! \brief Send end packets for DTMF */
2402 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2403 {
2404         unsigned int *rtpheader;
2405         int hdrlen = 12, res = 0, i = 0;
2406         char data[256];
2407         
2408         /* If no address, then bail out */
2409         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2410                 return 0;
2411         
2412         if ((digit <= '9') && (digit >= '0'))
2413                 digit -= '0';
2414         else if (digit == '*')
2415                 digit = 10;
2416         else if (digit == '#')
2417                 digit = 11;
2418         else if ((digit >= 'A') && (digit <= 'D'))
2419                 digit = digit - 'A' + 12;
2420         else if ((digit >= 'a') && (digit <= 'd'))
2421                 digit = digit - 'a' + 12;
2422         else {
2423                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2424                 return 0;
2425         }
2426
2427         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2428
2429         rtpheader = (unsigned int *)data;
2430         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2431         rtpheader[1] = htonl(rtp->lastdigitts);
2432         rtpheader[2] = htonl(rtp->ssrc);
2433         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2434         /* Set end bit */
2435         rtpheader[3] |= htonl((1 << 23));
2436         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2437         /* Send 3 termination packets */
2438         for (i = 0; i < 3; i++) {
2439                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2440                 if (res < 0)
2441                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2442                                 ast_inet_ntoa(rtp->them.sin_addr),
2443                                 ntohs(rtp->them.sin_port), strerror(errno));
2444                 if (rtp_debug_test_addr(&rtp->them))
2445                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2446                                     ast_inet_ntoa(rtp->them.sin_addr),
2447                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2448         }
2449         rtp->sending_digit = 0;
2450         rtp->send_digit = 0;
2451         /* Increment lastdigitts */
2452         rtp->lastdigitts += 960;
2453         rtp->seqno++;
2454
2455         return res;
2456 }
2457
2458 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2459 int ast_rtcp_send_h261fur(void *data)
2460 {
2461         struct ast_rtp *rtp = data;
2462         int res;
2463
2464         rtp->rtcp->sendfur = 1;
2465         res = ast_rtcp_write(data);
2466         
2467         return res;
2468 }
2469
2470 /*! \brief Send RTCP sender's report */
2471 static int ast_rtcp_write_sr(void *data)
2472 {
2473         struct ast_rtp *rtp = data;
2474         int res;
2475         int len = 0;
2476         struct timeval now;
2477         unsigned int now_lsw;
2478         unsigned int now_msw;
2479         unsigned int *rtcpheader;
2480         unsigned int lost;
2481         unsigned int extended;
2482         unsigned int expected;
2483         unsigned int expected_interval;
2484         unsigned int received_interval;
2485         int lost_interval;
2486         int fraction;
2487         struct timeval dlsr;
2488         char bdata[512];
2489
2490         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2491         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2492                 return 0;
2493         
2494         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2495                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2496                 if (rtp->rtcp->schedid > 0)
2497                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2498                 rtp->rtcp->schedid = -1;
2499                 return 0;
2500         }
2501
2502         gettimeofday(&now, NULL);
2503         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2504         rtcpheader = (unsigned int *)bdata;
2505         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2506         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2507         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2508         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2509         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2510         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2511         len += 28;
2512         
2513         extended = rtp->cycles + rtp->lastrxseqno;
2514         expected = extended - rtp->seedrxseqno + 1;
2515         if (rtp->rxcount > expected) 
2516                 expected += rtp->rxcount - expected;
2517         lost = expected - rtp->rxcount;
2518         expected_interval = expected - rtp->rtcp->expected_prior;
2519         rtp->rtcp->expected_prior = expected;
2520         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2521         rtp->rtcp->received_prior = rtp->rxcount;
2522         lost_interval = expected_interval - received_interval;
2523         if (expected_interval == 0 || lost_interval <= 0)
2524                 fraction = 0;
2525         else
2526                 fraction = (lost_interval << 8) / expected_interval;
2527         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2528         rtcpheader[7] = htonl(rtp->themssrc);
2529         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2530         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2531         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2532         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2533         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2534         len += 24;
2535         
2536         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2537
2538         if (rtp->rtcp->sendfur) {
2539                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2540                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2541                 len += 8;
2542                 rtp->rtcp->sendfur = 0;
2543         }
2544         
2545         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2546         /* it can change mid call, and SDES can't) */
2547         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2548         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2549         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2550         len += 12;
2551         
2552         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2553         if (res < 0) {
2554                 ast_log(LOG_ERROR, "RTCP SR transmission error to %s:%d, rtcp halted %s\n",ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), strerror(errno));
2555                 if (rtp->rtcp->schedid > 0)
2556                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2557                 rtp->rtcp->schedid = -1;
2558                 return 0;
2559         }
2560         
2561         /* FIXME Don't need to get a new one */
2562         gettimeofday(&rtp->rtcp->txlsr, NULL);
2563         rtp->rtcp->sr_count++;
2564
2565         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2566         
2567         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2568                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2569                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2570                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2571                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2572                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2573                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2574                 ast_verbose("  Report block:\n");
2575                 ast_verbose("  Fraction lost: %u\n", fraction);
2576                 ast_verbose("  Cumulative loss: %u\n", lost);
2577                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2578                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2579                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2580         }
2581         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2582                                             "OurSSRC: %u\r\n"
2583                                             "SentNTP: %u.%010u\r\n"
2584                                             "SentRTP: %u\r\n"
2585                                             "SentPackets: %u\r\n"
2586                                             "SentOctets: %u\r\n"
2587                                             "ReportBlock:\r\n"
2588                                             "FractionLost: %u\r\n"
2589                                             "CumulativeLoss: %u\r\n"
2590                                             "IAJitter: %.4f\r\n"
2591                                             "TheirLastSR: %u\r\n"
2592                                             "DLSR: %4.4f (sec)\r\n",
2593                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2594                                             rtp->ssrc,
2595                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2596                                             rtp->lastts,
2597                                             rtp->txcount,
2598                                             rtp->txoctetcount,
2599                                             fraction,
2600                                             lost,
2601                                             rtp->rxjitter,
2602                                             rtp->rtcp->themrxlsr,
2603                                             (double)(ntohl(rtcpheader[12])/65536.0));
2604         return res;
2605 }
2606
2607 /*! \brief Send RTCP recipient's report */
2608 static int ast_rtcp_write_rr(void *data)
2609 {
2610         struct ast_rtp *rtp = data;
2611         int res;
2612         int len = 32;
2613         unsigned int lost;
2614         unsigned int extended;
2615         unsigned int expected;
2616         unsigned int expected_interval;
2617         unsigned int received_interval;
2618         int lost_interval;
2619         struct timeval now;
2620         unsigned int *rtcpheader;
2621         char bdata[1024];
2622         struct timeval dlsr;
2623         int fraction;
2624
2625         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2626                 return 0;
2627           
2628         if (!rtp->rtcp->them.sin_addr.s_addr) {
2629                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2630                 if (rtp->rtcp->schedid > 0)
2631                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2632                 rtp->rtcp->schedid = -1;
2633                 return 0;
2634         }
2635
2636         extended = rtp->cycles + rtp->lastrxseqno;
2637         expected = extended - rtp->seedrxseqno + 1;
2638         lost = expected - rtp->rxcount;
2639         expected_interval = expected - rtp->rtcp->expected_prior;
2640         rtp->rtcp->expected_prior = expected;
2641         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2642         rtp->rtcp->received_prior = rtp->rxcount;
2643         lost_interval = expected_interval - received_interval;
2644         if (expected_interval == 0 || lost_interval <= 0)
2645                 fraction = 0;
2646         else
2647                 fraction = (lost_interval << 8) / expected_interval;
2648         gettimeofday(&now, NULL);
2649         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2650         rtcpheader = (unsigned int *)bdata;
2651         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2652         rtcpheader[1] = htonl(rtp->ssrc);
2653         rtcpheader[2] = htonl(rtp->themssrc);
2654         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2655         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2656         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2657         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2658         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2659
2660         if (rtp->rtcp->sendfur) {
2661                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2662                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2663                 len += 8;
2664                 rtp->rtcp->sendfur = 0;
2665         }
2666
2667         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2668         it can change mid call, and SDES can't) */
2669         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2670         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2671         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2672         len += 12;
2673         
2674         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2675
2676         if (res < 0) {
2677                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2678                 /* Remove the scheduler */
2679                 if (rtp->rtcp->schedid > 0)
2680                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2681                 rtp->rtcp->schedid = -1;
2682                 return 0;
2683         }
2684
2685         rtp->rtcp->rr_count++;
2686
2687         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2688                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2689                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2690                         "  IA jitter: %.4f\n" 
2691                         "  Their last SR: %u\n" 
2692                         "  DLSR: %4.4f (sec)\n\n",
2693                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2694                         ntohs(rtp->rtcp->them.sin_port),
2695                         rtp->ssrc, rtp->themssrc, fraction, lost,
2696                         rtp->rxjitter,
2697                         rtp->rtcp->themrxlsr,
2698                         (double)(ntohl(rtcpheader[7])/65536.0));
2699         }
2700
2701         return res;
2702 }
2703
2704 /*! \brief Write and RTCP packet to the far end
2705  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2706  * RR is sent if we have not sent any rtp packets in the previous interval */
2707 static int ast_rtcp_write(void *data)
2708 {
2709         struct ast_rtp *rtp = data;
2710         int res;
2711         
2712         if (!rtp || !rtp->rtcp)
2713                 return 0;
2714
2715         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2716                 res = ast_rtcp_write_sr(data);
2717         else
2718                 res = ast_rtcp_write_rr(data);
2719         
2720         return res;
2721 }
2722
2723 /*! \brief generate comfort noice (CNG) */
2724 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2725 {
2726         unsigned int *rtpheader;
2727         int hdrlen = 12;
2728         int res;
2729         int payload;
2730         char data[256];
2731         level = 127 - (level & 0x7f);
2732         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2733
2734         /* If we have no peer, return immediately */    
2735         if (!rtp->them.sin_addr.s_addr)
2736                 return 0;
2737
2738         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2739
2740         /* Get a pointer to the header */
2741         rtpheader = (unsigned int *)data;
2742         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2743         rtpheader[1] = htonl(rtp->lastts);
2744         rtpheader[2] = htonl(rtp->ssrc); 
2745         data[12] = level;
2746         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2747                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2748                 if (res <0) 
2749                         ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
2750                 if (rtp_debug_test_addr(&rtp->them))
2751                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2752                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2753                    
2754         }
2755         return 0;
2756 }
2757
2758 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2759 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2760 {
2761         unsigned char *rtpheader;
2762         int hdrlen = 12;
2763         int res;
2764         unsigned int ms;
2765         int pred;
2766         int mark = 0;
2767
2768         ms = calc_txstamp(rtp, &f->delivery);
2769         /* Default prediction */
2770         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2771                 pred = rtp->lastts + f->samples;
2772
2773                 /* Re-calculate last TS */
2774                 rtp->lastts = rtp->lastts + ms * 8;
2775                 if (ast_tvzero(f->delivery)) {
2776                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2777                            and if so, go with our prediction */
2778                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2779                                 rtp->lastts = pred;
2780                         else {
2781                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2782                                 mark = 1;
2783                         }
2784                 }
2785         } else if(f->subclass < AST_FORMAT_MAX_VIDEO) {
2786                 mark = f->subclass & 0x1;
2787                 pred = rtp->lastovidtimestamp + f->samples;
2788                 /* Re-calculate last TS */
2789                 rtp->lastts = rtp->lastts + ms * 90;
2790                 /* If it's close to our prediction, go for it */
2791                 if (ast_tvzero(f->delivery)) {
2792                         if (abs(rtp->lastts - pred) < 7200) {
2793                                 rtp->lastts = pred;
2794                                 rtp->lastovidtimestamp += f->samples;
2795                         } else {
2796                                 ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
2797                                 rtp->lastovidtimestamp = rtp->lastts;
2798                         }
2799                 }
2800         } else {
2801                 pred = rtp->lastotexttimestamp + f->samples;
2802                 /* Re-calculate last TS */
2803                 rtp->lastts = rtp->lastts + ms * 90;
2804                 /* If it's close to our prediction, go for it */
2805                 if (ast_tvzero(f->delivery)) {
2806                         if (abs(rtp->lastts - pred) < 7200) {
2807                                 rtp->lastts = pred;
2808                                 rtp->lastotexttimestamp += f->samples;
2809                         } else {
2810                                 ast_debug(3, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
2811                                 rtp->lastotexttimestamp = rtp->lastts;
2812                         }
2813                 }
2814         }
2815         /* If the timestamp for non-digit packets has moved beyond the timestamp
2816            for digits, update the digit timestamp.
2817         */
2818         if (rtp->lastts > rtp->lastdigitts)
2819                 rtp->lastdigitts = rtp->lastts;
2820
2821         if (f->has_timing_info)
2822                 rtp->lastts = f->ts * 8;
2823
2824         /* Get a pointer to the header */
2825         rtpheader = (unsigned char *)(f->data - hdrlen);
2826
2827         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2828         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2829         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2830
2831         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2832                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2833                 if (res <0) {
2834                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2835                                 ast_debug(1, "RTP Transmission error of packet %d to %s:%d: %s\n", rtp->seqno, ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
2836                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2837                                 /* Only give this error message once if we are not RTP debugging */
2838                                 if (option_debug || rtpdebug)
2839                                         ast_debug(0, "RTP NAT: Can't write RTP to private address %s:%d, waiting for other end to send audio...\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
2840                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2841                         }
2842                 } else {
2843                         rtp->txcount++;
2844                         rtp->txoctetcount +=(res - hdrlen);
2845                         
2846                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2847                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2848                 }
2849                                 
2850                 if (rtp_debug_test_addr(&rtp->them))
2851                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2852                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2853         }
2854
2855         rtp->seqno++;
2856
2857         return 0;
2858 }
2859
2860 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2861 {
2862         int x;
2863         for (x = 0; x < 32; x++) {  /* Ugly way */
2864                 rtp->pref.order[x] = prefs->order[x];
2865                 rtp->pref.framing[x] = prefs->framing[x];
2866         }
2867         if (rtp->smoother)
2868                 ast_smoother_free(rtp->smoother);
2869         rtp->smoother = NULL;
2870         return 0;
2871 }
2872
2873 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2874 {
2875         return &rtp->pref;
2876 }
2877
2878 int ast_rtp_codec_getformat(int pt)
2879 {
2880         if (pt < 0 || pt > MAX_RTP_PT)
2881                 return 0; /* bogus payload type */
2882
2883         if (static_RTP_PT[pt].isAstFormat)
2884                 return static_RTP_PT[pt].code;
2885         else
2886                 return 0;
2887 }
2888
2889 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2890 {
2891         struct ast_frame *f;
2892         int codec;
2893         int hdrlen = 12;
2894         int subclass;
2895         
2896
2897         /* If we have no peer, return immediately */    
2898         if (!rtp->them.sin_addr.s_addr)
2899                 return 0;
2900
2901         /* If there is no data length, return immediately */
2902         if (!_f->datalen) 
2903                 return 0;
2904         
2905         /* Make sure we have enough space for RTP header */
2906         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
2907                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
2908                 return -1;
2909         }
2910
2911         /* The bottom bit of a video subclass contains the marker bit */
2912         subclass = _f->subclass;
2913         if (_f->frametype == AST_FRAME_VIDEO)
2914                 subclass &= ~0x1;
2915
2916         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2917         if (codec < 0) {
2918                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2919                 return -1;
2920         }
2921
2922         if (rtp->lasttxformat != subclass) {
2923                 /* New format, reset the smoother */
2924                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2925                 rtp->lasttxformat = subclass;
2926                 if (rtp->smoother)
2927                         ast_smoother_free(rtp->smoother);
2928                 rtp->smoother = NULL;
2929         }
2930
2931         if (!rtp->smoother && subclass != AST_FORMAT_SPEEX) {
2932                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2933                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2934                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2935                                 ast_log(LOG_WARNING, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2936                                 return -1;
2937                         }
2938                         if (fmt.flags)
2939                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2940                         ast_debug(1, "Created smoother: format: %d ms: %d len: %d\n", subclass, fmt.cur_ms, ((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms));
2941                 }
2942         }
2943         if (rtp->smoother) {
2944                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2945                         ast_smoother_feed_be(rtp->smoother, _f);
2946                 } else {
2947                         ast_smoother_feed(rtp->smoother, _f);
2948                 }
2949
2950                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data))
2951                         ast_rtp_raw_write(rtp, f, codec);
2952         } else {
2953                 /* Don't buffer outgoing frames; send them one-per-packet: */
2954                 if (_f->offset < hdrlen) 
2955                         f = ast_frdup(_f);      /*! \bug XXX this might never be free'd. Why do we do this? */
2956                 else
2957                         f = _f;
2958                 if (f->data)
2959                         ast_rtp_raw_write(rtp, f, codec);
2960                 if (f != _f)
2961                         ast_frfree(f);
2962         }
2963                 
2964         return 0;
2965 }
2966
2967 /*! \brief Unregister interface to channel driver */
2968 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2969 {
2970         AST_RWLIST_WRLOCK(&protos);
2971         AST_RWLIST_REMOVE(&protos, proto, list);
2972         AST_RWLIST_UNLOCK(&protos);
2973 }
2974
2975 /*! \brief Register interface to channel driver */
2976 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2977 {
2978         struct ast_rtp_protocol *cur;
2979
2980         AST_RWLIST_WRLOCK(&protos);
2981         AST_RWLIST_TRAVERSE(&protos, cur, list) {       
2982                 if (!strcmp(cur->type, proto->type)) {
2983                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2984                         AST_RWLIST_UNLOCK(&protos);
2985                         return -1;
2986                 }
2987         }
2988         AST_RWLIST_INSERT_HEAD(&protos, proto, list);
2989         AST_RWLIST_UNLOCK(&protos);
2990         
2991         return 0;
2992 }
2993
2994 /*! \brief Bridge loop for true native bridge (reinvite) */
2995 static enum ast_bridge_result bridge_native_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, struct ast_rtp *vp0, struct ast_rtp *vp1, struct ast_rtp *tp0, struct ast_rtp *tp1, struct ast_rtp_protocol *pr0, struct ast_rtp_protocol *pr1, int codec0, int codec1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
2996 {
2997         struct ast_frame *fr = NULL;
2998         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2999         int oldcodec0 = codec0, oldcodec1 = codec1;
3000         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
3001         struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
3002         
3003         /* Set it up so audio goes directly between the two endpoints */
3004
3005         /* Test the first channel */
3006         if (!(pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
3007                 ast_rtp_get_peer(p1, &ac1);
3008                 if (vp1)
3009                         ast_rtp_get_peer(vp1, &vac1);
3010                 if (tp1)
3011                         ast_rtp_get_peer(tp1, &tac1);
3012         } else
3013                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
3014         
3015         /* Test the second channel */
3016         if (!(pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
3017                 ast_rtp_get_peer(p0, &ac0);
3018                 if (vp0)
3019                         ast_rtp_get_peer(vp0, &vac0);
3020                 if (tp0)
3021                         ast_rtp_get_peer(tp0, &tac0);
3022         } else
3023                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
3024
3025         /* Now we can unlock and move into our loop */
3026         ast_channel_unlock(c0);
3027         ast_channel_unlock(c1);
3028
3029         /* Throw our channels into the structure and enter the loop */
3030         cs[0] = c0;
3031         cs[1] = c1;
3032         cs[2] = NULL;
3033         for (;;) {
3034                 /* Check if anything changed */
3035                 if ((c0->tech_pvt != pvt0) ||
3036                     (c1->tech_pvt != pvt1) ||
3037                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
3038                         ast_debug(1, "Oooh, something is weird, backing out\n");
3039                         if (c0->tech_pvt == pvt0)
3040                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3041                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3042                         if (c1->tech_pvt == pvt1)
3043                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3044                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3045                         return AST_BRIDGE_RETRY;
3046                 }
3047
3048                 /* Check if they have changed their address */
3049                 ast_rtp_get_peer(p1, &t1);
3050                 if (vp1)
3051                         ast_rtp_get_peer(vp1, &vt1);
3052                 if (tp1)
3053                         ast_rtp_get_peer(tp1, &tt1);
3054                 if (pr1->get_codec)
3055                         codec1 = pr1->get_codec(c1);
3056                 ast_rtp_get_peer(p0, &t0);
3057                 if (vp0)
3058                         ast_rtp_get_peer(vp0, &vt0);
3059                 if (tp0)
3060                         ast_rtp_get_peer(tp0, &tt0);
3061                 if (pr0->get_codec)
3062                         codec0 = pr0->get_codec(c0);
3063                 if ((inaddrcmp(&t1, &ac1)) ||
3064                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
3065                     (tp1 && inaddrcmp(&tt1, &tac1)) ||
3066                     (codec1 != oldcodec1)) {
3067                         ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
3068                                 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
3069                         ast_debug(2, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
3070                                 c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
3071                         ast_debug(2, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
3072                                 c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
3073                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3074                                 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
3075                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3076                                 c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
3077                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3078                                 c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
3079                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, tt1.sin_addr.s_addr ? tp1 : NULL, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))
3080                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
3081                         memcpy(&ac1, &t1, sizeof(ac1));
3082                         memcpy(&vac1, &vt1, sizeof(vac1));
3083                         memcpy(&tac1, &tt1, sizeof(tac1));
3084                         oldcodec1 = codec1;
3085                 }
3086                 if ((inaddrcmp(&t0, &ac0)) ||
3087                     (vp0 && inaddrcmp(&vt0, &vac0)) ||
3088                     (tp0 && inaddrcmp(&tt0, &tac0))) {
3089                         ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
3090                                 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
3091                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",
3092                                 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
3093                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, tt0.sin_addr.s_addr ? tp0 : NULL, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))
3094                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
3095                         memcpy(&ac0, &t0, sizeof(ac0));
3096                         memcpy(&vac0, &vt0, sizeof(vac0));
3097                         memcpy(&tac0, &tt0, sizeof(tac0));
3098                         oldcodec0 = codec0;
3099                 }
3100
3101                 /* Wait for frame to come in on the channels */
3102                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3103                         if (!timeoutms) {
3104                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3105                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3106                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3107                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3108                                 return AST_BRIDGE_RETRY;
3109                         }
3110                         ast_debug(1, "Ooh, empty read...\n");
3111                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3112                                 break;
3113                         continue;
3114                 }
3115                 fr = ast_read(who);
3116                 other = (who == c0) ? c1 : c0;
3117                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3118                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
3119                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
3120                         /* Break out of bridge */
3121                         *fo = fr;
3122                         *rc = who;
3123                         ast_debug(1, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3124                         if (c0->tech_pvt == pvt0)
3125                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3126                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3127                         if (c1->tech_pvt == pvt1)
3128                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3129                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3130                         return AST_BRIDGE_COMPLETE;
3131                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3132                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3133                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3134                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3135                                 if (fr->subclass == AST_CONTROL_HOLD) {
3136                                         /* If we someone went on hold we want the other side to reinvite back to us */
3137                                         if (who == c0)
3138                                                 pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0);
3139                                         else
3140                                                 pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0);
3141                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3142                                         /* If they went off hold they should go back to being direct */
3143                                         if (who == c0)
3144                                                 pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
3145                                         else
3146                                                 pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
3147                                 }
3148                                 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3149                                 ast_frfree(fr);
3150                         } else {
3151                                 *fo = fr;
3152                                 *rc = who;
3153                                 ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3154                                 return AST_BRIDGE_COMPLETE;
3155                         }
3156                 } else {
3157                         if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3158                             (fr->frametype == AST_FRAME_DTMF) ||
3159                             (fr->frametype == AST_FRAME_VOICE) ||
3160                             (fr->frametype == AST_FRAME_VIDEO) ||
3161                             (fr->frametype == AST_FRAME_IMAGE) ||
3162                             (fr->frametype == AST_FRAME_HTML) ||
3163                             (fr->frametype == AST_FRAME_MODEM) ||
3164                             (fr->frametype == AST_FRAME_TEXT)) {
3165                                 ast_write(other, fr);
3166                         }
3167                         ast_frfree(fr);
3168                 }
3169                 /* Swap priority */
3170                 cs[2] = cs[0];
3171                 cs[0] = cs[1];
3172                 cs[1] = cs[2];
3173         }
3174
3175         if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3176                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3177         if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3178                 ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3179
3180         return AST_BRIDGE_FAILED;
3181 }
3182
3183 /*! \brief P2P RTP Callback */
3184 #ifdef P2P_INTENSE
3185 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
3186 {
3187         int res = 0, hdrlen = 12;
3188         struct sockaddr_in sin;
3189         socklen_t len;
3190         unsigned int *header;
3191         struct ast_rtp *rtp = cbdata, *bridged = NULL;
3192
3193         if (!rtp)
3194                 return 1;
3195
3196         len = sizeof(sin);
3197         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
3198                 return 1;
3199
3200         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
3201         
3202         /* If NAT support is turned on, then see if we need to change their address */
3203         if ((rtp->nat) && 
3204             ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
3205              (rtp->them.sin_port != sin.sin_port))) {
3206                 rtp->them = sin;
3207                 rtp->rxseqno = 0;
3208                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
3209                 if (option_debug || rtpdebug)
3210                         ast_debug(0, "P2P RTP NAT: Got audio from other end. Now sending to address %s:%d\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port));
3211         }
3212
3213         /* Write directly out to other RTP stream if bridged */
3214         if ((bridged = ast_rtp_get_bridged(rtp)))
3215                 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
3216         
3217         return 1;
3218 }
3219
3220 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3221 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3222 {
3223         /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3224         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
3225                 return 0;
3226
3227         /* If the RTP structure is already in callback mode, remove it temporarily */
3228         if (rtp->ioid) {
3229                 ast_io_remove(rtp->io, rtp->ioid);
3230                 rtp->ioid = NULL;
3231         }
3232
3233         /* Steal the file descriptors from the channel */
3234         chan->fds[0] = -1;
3235
3236         /* Now, fire up callback mode */
3237         iod[0] = ast_io_add(rtp->io, ast_rtp_fd(rtp), p2p_rtp_callback, AST_IO_IN, rtp);
3238
3239         return 1;
3240 }
3241 #else
3242 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3243 {
3244         return 0;
3245 }
3246 #endif
3247
3248 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3249 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3250 {
3251         ast_channel_lock(chan);
3252
3253         /* Remove the callback from the IO context */
3254         ast_io_remove(rtp->io, iod[0]);
3255
3256         /* Restore file descriptors */
3257         chan->fds[0] = ast_rtp_fd(rtp);
3258         ast_channel_unlock(chan);
3259
3260         /* Restore callback mode if previously used */
3261         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3262                 rtp->ioid = ast_io_add(rtp->io, ast_rtp_fd(rtp), rtpread, AST_IO_IN, rtp);
3263
3264         return 0;
3265 }
3266
3267 /*! \brief Helper function that sets what an RTP structure is bridged to */
3268 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3269 {
3270         rtp_bridge_lock(rtp0);
3271         rtp0->bridged = rtp1;
3272         rtp_bridge_unlock(rtp0);
3273
3274         return;
3275 }
3276
3277 /*! \brief Bridge loop for partial native bridge (packet2packet) 
3278
3279         In p2p mode, Asterisk is a very basic RTP proxy, just forwarding whatever
3280         rtp/rtcp we get in to the channel. 
3281         \note this currently only works for Audio
3282 */
3283 static enum ast_bridge_result bridge_p2p_loop(struct ast_channel *c0, struct ast_channel *c1, struct ast_rtp *p0, struct ast_rtp *p1, int timeoutms, int flags, struct ast_frame **fo, struct ast_channel **rc, void *pvt0, void *pvt1)
3284 {
3285         struct ast_frame *fr = NULL;
3286         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3287         int *p0_iod[2] = {NULL, NULL}, *p1_iod[2] = {NULL, NULL};
3288         int p0_callback = 0, p1_callback = 0;
3289         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3290
3291         /* Okay, setup each RTP structure to do P2P forwarding */
3292         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3293         p2p_set_bridge(p0, p1);
3294         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3295         p2p_set_bridge(p1, p0);
3296
3297         /* Activate callback modes if possible */
3298         p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
3299         p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
3300
3301         /* Now let go of the channel locks and be on our way */
3302         ast_channel_unlock(c0);
3303         ast_channel_unlock(c1);
3304
3305         /* Go into a loop forwarding frames until we don't need to anymore */
3306         cs[0] = c0;
3307         cs[1] = c1;
3308         cs[2] = NULL;
3309         for (;;) {
3310                 /* Check if anything changed */
3311                 if ((c0->tech_pvt != pvt0) ||
3312                     (c1->tech_pvt != pvt1) ||
3313                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
3314                         ast_debug(3, "p2p-rtp-bridge: Oooh, something is weird, backing out\n");
3315                         /* If a masquerade needs to happen we have to try to read in a frame so that it actually happens. Without this we risk being called again and going into a loop */
3316                         if ((c0->masq || c0->masqr) && (fr = ast_read(c0)))
3317                                 ast_frfree(fr);
3318                         if ((c1->masq || c1->masqr) && (fr = ast_read(c1)))
3319                                 ast_frfree(fr);
3320                         res = AST_BRIDGE_RETRY;
3321                         break;
3322                 }
3323                 /* Wait on a channel to feed us a frame */
3324                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3325                         if (!timeoutms) {
3326                                 res = AST_BRIDGE_RETRY;
3327                                 break;
3328                         }
3329                         if (option_debug > 2)
3330                                 ast_log(LOG_NOTICE, "p2p-rtp-bridge: Ooh, empty read...\n");
3331                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3332                                 break;
3333                         continue;
3334                 }
3335                 /* Read in frame from channel */
3336                 fr = ast_read(who);
3337                 other = (who == c0) ? c1 : c0;
3338                 /* Depending on the frame we may need to break out of our bridge */
3339                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3340                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3341                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3342                         /* Record received frame and who */
3343                         *fo = fr;
3344                         *rc = who;
3345                         ast_debug(3, "p2p-rtp-bridge: Ooh, got a %s\n", fr ? "digit" : "hangup");
3346                         res = AST_BRIDGE_COMPLETE;
3347                         break;
3348                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3349                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3350                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3351                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3352                                 /* If we are going on hold, then break callback mode and P2P bridging */
3353                                 if (fr->subclass == AST_CONTROL_HOLD) {
3354                                         if (p0_callback)
3355                                                 p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
3356                                         if (p1_callback)
3357                                                 p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
3358                                         p2p_set_bridge(p0, NULL);
3359                                         p2p_set_bridge(p1, NULL);
3360                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3361                                         /* If we are off hold, then go back to callback mode and P2P bridging */
3362                                         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3363                                         p2p_set_bridge(p0, p1);
3364                                         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3365                                         p2p_set_bridge(p1, p0);
3366                                         p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
3367                                         p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
3368                                 }
3369                                 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3370                                 ast_frfree(fr);
3371                         } else {
3372                                 *fo = fr;
3373                                 *rc = who;
3374                                 ast_debug(3, "p2p-rtp-bridge: Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3375                                 res = AST_BRIDGE_COMPLETE;
3376                                 break;
3377                         }
3378                 } else {
3379                         if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3380                             (fr->frametype == AST_FRAME_DTMF) ||
3381                             (fr->frametype == AST_FRAME_VOICE) ||
3382                             (fr->frametype == AST_FRAME_VIDEO) ||
3383                             (fr->frametype == AST_FRAME_IMAGE) ||
3384                             (fr->frametype == AST_FRAME_HTML) ||
3385                             (fr->frametype == AST_FRAME_MODEM) ||
3386                             (fr->frametype == AST_FRAME_TEXT)) {
3387                                 ast_write(other, fr);
3388                         }
3389
3390                         ast_frfree(fr);
3391                 }
3392                 /* Swap priority */
3393                 cs[2] = cs[0];
3394                 cs[0] = cs[1];
3395                 cs[1] = cs[2];
3396         }
3397
3398         /* If we are totally avoiding the core, then restore our link to it */
3399         if (p0_callback)
3400                 p0_callback = p2p_callback_disable(c0, p0, &p0_iod[0]);
3401         if (p1_callback)
3402                 p1_callback = p2p_callback_disable(c1, p1, &p1_iod[0]);
3403
3404         /* Break out of the direct bridge */
3405         p2p_set_bridge(p0, NULL);
3406         p2p_set_bridge(p1, NULL);
3407
3408         return res;
3409 }
3410
3411 /*! \page AstRTPbridge The Asterisk RTP bridge 
3412         The RTP bridge is called from the channel drivers that are using the RTP
3413         subsystem in Asterisk - like SIP, H.323 and Jingle/Google Talk.
3414
3415         This bridge aims to offload the Asterisk server by setting up
3416         the media stream directly between the endpoints, keeping the
3417         signalling in Asterisk.
3418
3419         It checks with the channel driver, using a callback function, if
3420         there are possibilities for a remote bridge.
3421
3422         If this fails, the bridge hands off to the core bridge. Reasons
3423         can be NAT support needed, DTMF features in audio needed by
3424         the PBX for transfers or spying/monitoring on channels.
3425
3426         If transcoding is needed - we can't do a remote bridge.
3427         If only NAT support is needed, we're using Asterisk in
3428         RTP proxy mode with the p2p RTP bridge, basically
3429         forwarding incoming audio packets to the outbound
3430         stream on a network level.
3431
3432         References:
3433         - ast_rtp_bridge()
3434         - ast_channel_early_bridge()
3435         - ast_channel_bridge()
3436         - rtp.c
3437         - rtp.h
3438 */
3439 /*! \brief Bridge calls. If possible and allowed, initiate
3440         re-invite so the peers exchange media directly outside 
3441         of Asterisk. 
3442 */
3443 enum ast_bridge_result ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
3444 {
3445         struct ast_rtp *p0 = NULL, *p1 = NULL;          /* Audio RTP Channels */
3446         struct ast_rtp *vp0 = NULL, *vp1 = NULL;        /* Video RTP channels */
3447         struct ast_rtp *tp0 = NULL, *tp1 = NULL;        /* Text RTP channels */
3448         struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3449         enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED, text_p0_res = AST_RTP_GET_FAILED;
3450         enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED, text_p1_res = AST_RTP_GET_FAILED;
3451         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3452         int codec0 = 0, codec1 = 0;
3453         void *pvt0 = NULL, *pvt1 = NULL;
3454
3455         /* Lock channels */
3456         ast_channel_lock(c0);
3457         while (ast_channel_trylock(c1)) {
3458                 ast_channel_unlock(c0);
3459                 usleep(1);
3460                 ast_channel_lock(c0);
3461         }
3462
3463         /* Find channel driver interfaces */
3464         if (!(pr0 = get_proto(c0))) {
3465                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3466                 ast_channel_unlock(c0);
3467                 ast_channel_unlock(c1);
3468                 return AST_BRIDGE_FAILED;
3469         }
3470         if (!(pr1 = get_proto(c1))) {
3471                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3472                 ast_channel_unlock(c0);
3473                 ast_channel_unlock(c1);
3474                 return AST_BRIDGE_FAILED;
3475         }
3476
3477         /* Get channel specific interface structures */
3478         pvt0 = c0->tech_pvt;
3479         pvt1 = c1->tech_pvt;
3480
3481         /* Get audio and video interface (if native bridge is possible) */
3482         audio_p0_res = pr0->get_rtp_info(c0, &p0);
3483         video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3484         text_p0_res = pr0->get_trtp_info ? pr0->get_trtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3485         audio_p1_res = pr1->get_rtp_info(c1, &p1);
3486         video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3487         text_p1_res = pr1->get_trtp_info ? pr1->get_trtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3488
3489         /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3490         if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3491                 audio_p0_res = AST_RTP_GET_FAILED;
3492         if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3493                 audio_p1_res = AST_RTP_GET_FAILED;
3494
3495         /* Check if a bridge is possible (partial/native) */
3496         if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3497                 /* Somebody doesn't want to play... */
3498                 ast_channel_unlock(c0);
3499                 ast_channel_unlock(c1);
3500                 return AST_BRIDGE_FAILED_NOWARN;
3501         }
3502
3503         /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3504         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3505                 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3506                 audio_p0_res = AST_RTP_TRY_PARTIAL;
3507         }
3508
3509         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3510                 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3511                 audio_p1_res = AST_RTP_TRY_PARTIAL;
3512         }
3513
3514         /* If both sides are not using the same method of DTMF transmission 
3515          * (ie: one is RFC2833, other is INFO... then we can not do direct media. 
3516          * --------------------------------------------------
3517          * | DTMF Mode |  HAS_DTMF  |  Accepts Begin Frames |
3518          * |-----------|------------|-----------------------|
3519          * | Inband    | False      | True                  |
3520          * | RFC2833   | True       | True                  |
3521          * | SIP INFO  | False      | False                 |
3522          * --------------------------------------------------
3523          * However, if DTMF from both channels is being monitored by the core, then
3524          * we can still do packet-to-packet bridging, because passing through the 
3525          * core will handle DTMF mode translation.
3526          */
3527         if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) ||
3528                  (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) {
3529                 if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) {
3530                         ast_channel_unlock(c0);
3531                         ast_channel_unlock(c1);
3532                         return AST_BRIDGE_FAILED_NOWARN;
3533                 }
3534                 audio_p0_res = AST_RTP_TRY_PARTIAL;
3535                 audio_p1_res = AST_RTP_TRY_PARTIAL;
3536         }
3537
3538         /* If the core will need to compensate and the P2P bridge will need to feed up DTMF frames then we can not reliably do so yet, so do not P2P bridge */
3539         if ((audio_p0_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p0, FLAG_P2P_NEED_DTMF) && ast_test_flag(p0, FLAG_DTMF_COMPENSATE)) ||
3540             (audio_p1_res == AST_RTP_TRY_PARTIAL && ast_test_flag(p1, FLAG_P2P_NEED_DTMF) && ast_test_flag(p1, FLAG_DTMF_COMPENSATE))) {
3541                 ast_channel_unlock(c0);
3542                 ast_channel_unlock(c1);
3543                 return AST_BRIDGE_FAILED_NOWARN;
3544         }
3545
3546         /* Get codecs from both sides */
3547         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3548         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3549         if (codec0 && codec1 && !(codec0 & codec1)) {
3550                 /* Hey, we can't do native bridging if both parties speak different codecs */
3551                 ast_debug(3, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3552                 ast_channel_unlock(c0);
3553                 ast_channel_unlock(c1);
3554                 return AST_BRIDGE_FAILED_NOWARN;
3555         }
3556
3557