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