Merged revisions 59358 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 == EBADF)
924                         CRASH;
925                 if (errno != EAGAIN) {
926                         ast_log(LOG_WARNING, "RTCP Read error: %s.  Hanging up.\n", strerror(errno));
927                         return NULL;
928                 }
929                 return &ast_null_frame;
930         }
931
932         packetwords = res / 4;
933         
934         if (rtp->nat) {
935                 /* Send to whoever sent to us */
936                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
937                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
938                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
939                         if (option_debug || rtpdebug)
940                                 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));
941                 }
942         }
943
944         if (option_debug)
945                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
946
947         /* Process a compound packet */
948         position = 0;
949         while (position < packetwords) {
950                 i = position;
951                 length = ntohl(rtcpheader[i]);
952                 pt = (length & 0xff0000) >> 16;
953                 rc = (length & 0x1f000000) >> 24;
954                 length &= 0xffff;
955     
956                 if ((i + length) > packetwords) {
957                         ast_log(LOG_WARNING, "RTCP Read too short\n");
958                         return &ast_null_frame;
959                 }
960                 
961                 if (rtcp_debug_test_addr(&sin)) {
962                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
963                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
964                         ast_verbose("Reception reports: %d\n", rc);
965                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
966                 }
967     
968                 i += 2; /* Advance past header and ssrc */
969                 
970                 switch (pt) {
971                 case RTCP_PT_SR:
972                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
973                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
974                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
975                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
976     
977                         if (rtcp_debug_test_addr(&sin)) {
978                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
979                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
980                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
981                         }
982                         i += 5;
983                         if (rc < 1)
984                                 break;
985                         /* Intentional fall through */
986                 case RTCP_PT_RR:
987                         /* This is the place to calculate RTT */
988                         /* Don't handle multiple reception reports (rc > 1) yet */
989                         gettimeofday(&now, NULL);
990                         timeval2ntp(now, &msw, &lsw);
991                         /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */
992                         if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */
993                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
994                                 a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.);
995                                 lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.);
996                                 dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.);
997                                 rtt = a - dlsr - lsr;
998                                 rtp->rtcp->accumulated_transit += rtt;
999                                 rtp->rtcp->rtt = rtt;
1000                                 if (rtp->rtcp->maxrtt<rtt)
1001                                         rtp->rtcp->maxrtt = rtt;
1002                                 if (rtp->rtcp->minrtt>rtt)
1003                                 rtp->rtcp->minrtt = rtt;
1004                         }
1005                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
1006                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
1007                         if (rtcp_debug_test_addr(&sin)) {
1008                                 ast_verbose("Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
1009                                 ast_verbose("Packets lost so far: %d\n", rtp->rtcp->reported_lost);
1010                                 ast_verbose("Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
1011                                 ast_verbose("Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
1012                                 ast_verbose("Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
1013                                 ast_verbose("Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
1014                                 ast_verbose("DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
1015                                 if (rtt)
1016                                         ast_verbose("RTT: %f(sec)\n", rtt);
1017                         }
1018                         break;
1019                 case RTCP_PT_FUR:
1020                         if (rtcp_debug_test_addr(&sin))
1021                                 ast_verbose("Received an RTCP Fast Update Request\n");
1022                         rtp->f.frametype = AST_FRAME_CONTROL;
1023                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
1024                         rtp->f.datalen = 0;
1025                         rtp->f.samples = 0;
1026                         rtp->f.mallocd = 0;
1027                         rtp->f.src = "RTP";
1028                         f = &rtp->f;
1029                         break;
1030                 case RTCP_PT_SDES:
1031                         if (rtcp_debug_test_addr(&sin))
1032                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1033                         break;
1034                 case RTCP_PT_BYE:
1035                         if (rtcp_debug_test_addr(&sin))
1036                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
1037                         break;
1038                 default:
1039                         if (option_debug)
1040                                 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));
1041                         break;
1042                 }
1043                 position += (length + 1);
1044         }
1045                         
1046         return f;
1047 }
1048
1049 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
1050 {
1051         struct timeval now;
1052         double transit;
1053         double current_time;
1054         double d;
1055         double dtv;
1056         double prog;
1057         
1058         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
1059                 gettimeofday(&rtp->rxcore, NULL);
1060                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
1061                 /* map timestamp to a real time */
1062                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
1063                 rtp->rxcore.tv_sec -= timestamp / 8000;
1064                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
1065                 /* Round to 0.1ms for nice, pretty timestamps */
1066                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
1067                 if (rtp->rxcore.tv_usec < 0) {
1068                         /* Adjust appropriately if necessary */
1069                         rtp->rxcore.tv_usec += 1000000;
1070                         rtp->rxcore.tv_sec -= 1;
1071                 }
1072         }
1073
1074         gettimeofday(&now,NULL);
1075         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1076         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
1077         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
1078         if (tv->tv_usec >= 1000000) {
1079                 tv->tv_usec -= 1000000;
1080                 tv->tv_sec += 1;
1081         }
1082         prog = (double)((timestamp-rtp->seedrxts)/8000.);
1083         dtv = (double)rtp->drxcore + (double)(prog);
1084         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
1085         transit = current_time - dtv;
1086         d = transit - rtp->rxtransit;
1087         rtp->rxtransit = transit;
1088         if (d<0)
1089                 d=-d;
1090         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1091         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1092                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1093         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1094                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1095 }
1096
1097 /*! \brief Perform a Packet2Packet RTP write */
1098 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
1099 {
1100         int res = 0, payload = 0, bridged_payload = 0, version, padding, mark, ext;
1101         struct rtpPayloadType rtpPT;
1102         unsigned int seqno;
1103         
1104         /* Get fields from packet */
1105         seqno = ntohl(rtpheader[0]);
1106         version = (seqno & 0xC0000000) >> 30;
1107         payload = (seqno & 0x7f0000) >> 16;
1108         padding = seqno & (1 << 29);
1109         mark = (seqno & 0x800000) >> 23;
1110         ext = seqno & (1 << 28);
1111         seqno &= 0xffff;
1112
1113         /* Check what the payload value should be */
1114         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1115
1116         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1117         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1118                 return -1;
1119
1120         /* Otherwise adjust bridged payload to match */
1121         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1122
1123         /* If the mark bit has not been sent yet... do it now */
1124         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1125                 mark = 1;
1126                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1127         }
1128
1129         /* Reconstruct part of the packet */
1130         rtpheader[0] = htonl((version << 30) | (mark << 23) | (bridged_payload << 16) | (seqno));
1131
1132         /* Send the packet back out */
1133         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1134         if (res < 0) {
1135                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1136                         if (option_debug)
1137                                 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));
1138                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1139                         if (option_debug || rtpdebug)
1140                                 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));
1141                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1142                 }
1143                 return 0;
1144         } else if (rtp_debug_test_addr(&bridged->them))
1145                         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);
1146
1147         return 0;
1148 }
1149
1150 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1151 {
1152         int res;
1153         struct sockaddr_in sin;
1154         socklen_t len;
1155         unsigned int seqno;
1156         int version;
1157         int payloadtype;
1158         int tseqno;
1159         int hdrlen = 12;
1160         int padding;
1161         int mark;
1162         int ext;
1163         unsigned int ssrc;
1164         unsigned int timestamp;
1165         unsigned int *rtpheader;
1166         struct rtpPayloadType rtpPT;
1167         struct ast_rtp *bridged = NULL;
1168         
1169         /* If time is up, kill it */
1170         if (rtp->sending_digit)
1171                 ast_rtp_senddigit_continuation(rtp);
1172
1173         len = sizeof(sin);
1174         
1175         /* Cache where the header will go */
1176         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1177                                         0, (struct sockaddr *)&sin, &len);
1178
1179         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1180         if (res < 0) {
1181                 if (errno == EBADF)
1182                         CRASH;
1183                 if (errno != EAGAIN) {
1184                         ast_log(LOG_WARNING, "RTP Read error: %s.  Hanging up.\n", strerror(errno));
1185                         return NULL;
1186                 }
1187                 return &ast_null_frame;
1188         }
1189         
1190         if (res < hdrlen) {
1191                 ast_log(LOG_WARNING, "RTP Read too short\n");
1192                 return &ast_null_frame;
1193         }
1194
1195         /* Get fields */
1196         seqno = ntohl(rtpheader[0]);
1197
1198         /* Check RTP version */
1199         version = (seqno & 0xC0000000) >> 30;
1200         if (!version) {
1201                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
1202                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1203                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1204                 }
1205                 return &ast_null_frame;
1206         }
1207
1208 #if 0   /* Allow to receive RTP stream with closed transmission path */
1209         /* If we don't have the other side's address, then ignore this */
1210         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1211                 return &ast_null_frame;
1212 #endif
1213
1214         /* Send to whoever send to us if NAT is turned on */
1215         if (rtp->nat) {
1216                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1217                     (rtp->them.sin_port != sin.sin_port)) {
1218                         rtp->them = sin;
1219                         if (rtp->rtcp) {
1220                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1221                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1222                         }
1223                         rtp->rxseqno = 0;
1224                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1225                         if (option_debug || rtpdebug)
1226                                 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));
1227                 }
1228         }
1229
1230         /* If we are bridged to another RTP stream, send direct */
1231         if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen))
1232                 return &ast_null_frame;
1233
1234         if (version != 2)
1235                 return &ast_null_frame;
1236
1237         payloadtype = (seqno & 0x7f0000) >> 16;
1238         padding = seqno & (1 << 29);
1239         mark = seqno & (1 << 23);
1240         ext = seqno & (1 << 28);
1241         seqno &= 0xffff;
1242         timestamp = ntohl(rtpheader[1]);
1243         ssrc = ntohl(rtpheader[2]);
1244         
1245         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1246                 if (option_debug || rtpdebug)
1247                         ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
1248                 mark = 1;
1249         }
1250
1251         rtp->rxssrc = ssrc;
1252         
1253         if (padding) {
1254                 /* Remove padding bytes */
1255                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1256         }
1257         
1258         if (ext) {
1259                 /* RTP Extension present */
1260                 hdrlen += 4;
1261                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
1262                 if (option_debug) {
1263                         int profile;
1264                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1265                         if (profile == 0x505a)
1266                                 ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1267                         else
1268                                 ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile);
1269                 }
1270         }
1271
1272         if (res < hdrlen) {
1273                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1274                 return &ast_null_frame;
1275         }
1276
1277         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1278
1279         tseqno = rtp->lastrxseqno +1;
1280
1281         if (rtp->rxcount==1) {
1282                 /* This is the first RTP packet successfully received from source */
1283                 rtp->seedrxseqno = seqno;
1284         }
1285
1286         /* Do not schedule RR if RTCP isn't run */
1287         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1288                 /* Schedule transmission of Receiver Report */
1289                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1290         }
1291
1292         if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */
1293                 rtp->cycles += RTP_SEQ_MOD;
1294                 ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno);
1295         }
1296
1297         rtp->lastrxseqno = seqno;
1298         
1299         if (rtp->themssrc==0)
1300                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1301         
1302         if (rtp_debug_test_addr(&sin))
1303                 ast_verbose("Got  RTP packet from    %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1304                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1305
1306         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1307         if (!rtpPT.isAstFormat) {
1308                 struct ast_frame *f = NULL;
1309
1310                 /* This is special in-band data that's not one of our codecs */
1311                 if (rtpPT.code == AST_RTP_DTMF) {
1312                         /* It's special -- rfc2833 process it */
1313                         if (rtp_debug_test_addr(&sin)) {
1314                                 unsigned char *data;
1315                                 unsigned int event;
1316                                 unsigned int event_end;
1317                                 unsigned int duration;
1318                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1319                                 event = ntohl(*((unsigned int *)(data)));
1320                                 event >>= 24;
1321                                 event_end = ntohl(*((unsigned int *)(data)));
1322                                 event_end <<= 8;
1323                                 event_end >>= 24;
1324                                 duration = ntohl(*((unsigned int *)(data)));
1325                                 duration &= 0xFFFF;
1326                                 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);
1327                         }
1328                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno, timestamp);
1329                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1330                         /* It's really special -- process it the Cisco way */
1331                         if (rtp->lastevent <= seqno || (rtp->lastevent >= 65530 && seqno <= 6)) {
1332                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1333                                 rtp->lastevent = seqno;
1334                         }
1335                 } else if (rtpPT.code == AST_RTP_CN) {
1336                         /* Comfort Noise */
1337                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1338                 } else {
1339                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1340                 }
1341                 return f ? f : &ast_null_frame;
1342         }
1343         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1344         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;
1345
1346         if (!rtp->lastrxts)
1347                 rtp->lastrxts = timestamp;
1348
1349         rtp->rxseqno = seqno;
1350
1351         /* Record received timestamp as last received now */
1352         rtp->lastrxts = timestamp;
1353
1354         rtp->f.mallocd = 0;
1355         rtp->f.datalen = res - hdrlen;
1356         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1357         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1358         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1359                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1360                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1361                         ast_frame_byteswap_be(&rtp->f);
1362                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1363                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1364                 rtp->f.has_timing_info = 1;
1365                 rtp->f.ts = timestamp / 8;
1366                 rtp->f.len = rtp->f.samples / 8;
1367                 rtp->f.seqno = seqno;
1368         } else if(rtp->f.subclass < AST_FORMAT_MAX_VIDEO) {
1369                 /* Video -- samples is # of samples vs. 90000 */
1370                 if (!rtp->lastividtimestamp)
1371                         rtp->lastividtimestamp = timestamp;
1372                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1373                 rtp->lastividtimestamp = timestamp;
1374                 rtp->f.delivery.tv_sec = 0;
1375                 rtp->f.delivery.tv_usec = 0;
1376                 if (mark)
1377                         rtp->f.subclass |= 0x1;
1378         } else {
1379                 /* TEXT -- samples is # of samples vs. 1000 */
1380                 if (!rtp->lastitexttimestamp)
1381                         rtp->lastitexttimestamp = timestamp;
1382                 rtp->f.samples = timestamp - rtp->lastitexttimestamp;
1383                 rtp->lastitexttimestamp = timestamp;
1384                 rtp->f.delivery.tv_sec = 0;
1385                 rtp->f.delivery.tv_usec = 0;
1386         }
1387         rtp->f.src = "RTP";
1388         return &rtp->f;
1389 }
1390
1391 /* The following array defines the MIME Media type (and subtype) for each
1392    of our codecs, or RTP-specific data type. */
1393 static struct {
1394         struct rtpPayloadType payloadType;
1395         char* type;
1396         char* subtype;
1397 } mimeTypes[] = {
1398         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1399         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1400         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1401         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1402         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1403         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1404         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1405         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1406         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1407         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1408         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1409         {{1, AST_FORMAT_G722}, "audio", "G722"},
1410         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1411         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1412         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1413         {{0, AST_RTP_CN}, "audio", "CN"},
1414         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1415         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1416         {{1, AST_FORMAT_H261}, "video", "H261"},
1417         {{1, AST_FORMAT_H263}, "video", "H263"},
1418         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1419         {{1, AST_FORMAT_H264}, "video", "H264"},
1420         {{1, AST_FORMAT_MP4_VIDEO}, "video", "MP4V-ES"},
1421         {{1, AST_FORMAT_T140}, "text", "T140"},
1422 };
1423
1424 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1425    also, our own choices for dynamic payload types.  This is our master
1426    table for transmission */
1427 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1428         [0] = {1, AST_FORMAT_ULAW},
1429 #ifdef USE_DEPRECATED_G726
1430         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1431 #endif
1432         [3] = {1, AST_FORMAT_GSM},
1433         [4] = {1, AST_FORMAT_G723_1},
1434         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1435         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1436         [7] = {1, AST_FORMAT_LPC10},
1437         [8] = {1, AST_FORMAT_ALAW},
1438         [9] = {1, AST_FORMAT_G722},
1439         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1440         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1441         [13] = {0, AST_RTP_CN},
1442         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1443         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1444         [18] = {1, AST_FORMAT_G729A},
1445         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1446         [26] = {1, AST_FORMAT_JPEG},
1447         [31] = {1, AST_FORMAT_H261},
1448         [34] = {1, AST_FORMAT_H263},
1449         [97] = {1, AST_FORMAT_ILBC},
1450         [99] = {1, AST_FORMAT_H264},
1451         [101] = {0, AST_RTP_DTMF},
1452         [102] = {1, AST_FORMAT_T140},   /* Real time text chat */
1453         [103] = {1, AST_FORMAT_H263_PLUS},
1454         [104] = {1, AST_FORMAT_MP4_VIDEO},
1455         [110] = {1, AST_FORMAT_SPEEX},
1456         [111] = {1, AST_FORMAT_G726},
1457         [112] = {1, AST_FORMAT_G726_AAL2},
1458         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1459 };
1460
1461 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1462 {
1463         int i;
1464
1465         if (!rtp)
1466                 return;
1467
1468         rtp_bridge_lock(rtp);
1469
1470         for (i = 0; i < MAX_RTP_PT; ++i) {
1471                 rtp->current_RTP_PT[i].isAstFormat = 0;
1472                 rtp->current_RTP_PT[i].code = 0;
1473         }
1474
1475         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1476         rtp->rtp_lookup_code_cache_code = 0;
1477         rtp->rtp_lookup_code_cache_result = 0;
1478
1479         rtp_bridge_unlock(rtp);
1480 }
1481
1482 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1483 {
1484         int i;
1485
1486         rtp_bridge_lock(rtp);
1487
1488         /* Initialize to default payload types */
1489         for (i = 0; i < MAX_RTP_PT; ++i) {
1490                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1491                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1492         }
1493
1494         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1495         rtp->rtp_lookup_code_cache_code = 0;
1496         rtp->rtp_lookup_code_cache_result = 0;
1497
1498         rtp_bridge_unlock(rtp);
1499 }
1500
1501 void ast_rtp_pt_copy(struct ast_rtp *dest, struct ast_rtp *src)
1502 {
1503         unsigned int i;
1504
1505         rtp_bridge_lock(dest);
1506         rtp_bridge_lock(src);
1507
1508         for (i=0; i < MAX_RTP_PT; ++i) {
1509                 dest->current_RTP_PT[i].isAstFormat = 
1510                         src->current_RTP_PT[i].isAstFormat;
1511                 dest->current_RTP_PT[i].code = 
1512                         src->current_RTP_PT[i].code; 
1513         }
1514         dest->rtp_lookup_code_cache_isAstFormat = 0;
1515         dest->rtp_lookup_code_cache_code = 0;
1516         dest->rtp_lookup_code_cache_result = 0;
1517
1518         rtp_bridge_unlock(src);
1519         rtp_bridge_unlock(dest);
1520 }
1521
1522 /*! \brief Get channel driver interface structure */
1523 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1524 {
1525         struct ast_rtp_protocol *cur = NULL;
1526
1527         AST_RWLIST_RDLOCK(&protos);
1528         AST_RWLIST_TRAVERSE(&protos, cur, list) {
1529                 if (cur->type == chan->tech->type)
1530                         break;
1531         }
1532         AST_RWLIST_UNLOCK(&protos);
1533
1534         return cur;
1535 }
1536
1537 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1538 {
1539         // dest = c0, src = c1
1540         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1541         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1542         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1543         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1544         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;
1545         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;
1546         int srccodec, destcodec, nat_active = 0;
1547
1548         /* Lock channels */
1549         ast_channel_lock(c0);
1550         if (c1) {
1551                 while (ast_channel_trylock(c1)) {
1552                         ast_channel_unlock(c0);
1553                         usleep(1);
1554                         ast_channel_lock(c0);
1555                 }
1556         }
1557
1558         /* Find channel driver interfaces */
1559         destpr = get_proto(c0);
1560         if (c1)
1561                 srcpr = get_proto(c1);
1562         if (!destpr) {
1563                 if (option_debug)
1564                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1565                 ast_channel_unlock(c0);
1566                 if (c1)
1567                         ast_channel_unlock(c1);
1568                 return -1;
1569         }
1570         if (!srcpr) {
1571                 if (option_debug)
1572                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1573                 ast_channel_unlock(c0);
1574                 if (c1)
1575                         ast_channel_unlock(c1);
1576                 return -1;
1577         }
1578
1579         /* Get audio, video  and text interface (if native bridge is possible) */
1580         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1581         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1582         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(c0, &tdestp) : AST_RTP_GET_FAILED;
1583         if (srcpr) {
1584                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1585                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1586                 text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(c1, &tsrcp) : AST_RTP_GET_FAILED;
1587         }
1588
1589         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1590         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1591                 /* Somebody doesn't want to play... */
1592                 ast_channel_unlock(c0);
1593                 if (c1)
1594                         ast_channel_unlock(c1);
1595                 return -1;
1596         }
1597         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1598                 srccodec = srcpr->get_codec(c1);
1599         else
1600                 srccodec = 0;
1601         if (audio_dest_res == AST_RTP_TRY_NATIVE && destpr->get_codec)
1602                 destcodec = destpr->get_codec(c0);
1603         else
1604                 destcodec = 0;
1605         /* Ensure we have at least one matching codec */
1606         if (!(srccodec & destcodec)) {
1607                 ast_channel_unlock(c0);
1608                 if (c1)
1609                         ast_channel_unlock(c1);
1610                 return 0;
1611         }
1612         /* Consider empty media as non-existant */
1613         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1614                 srcp = NULL;
1615         if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1616                 nat_active = 1;
1617         /* Bridge media early */
1618         if (destpr->set_rtp_peer(c0, srcp, vsrcp, tsrcp, srccodec, nat_active))
1619                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1620         ast_channel_unlock(c0);
1621         if (c1)
1622                 ast_channel_unlock(c1);
1623         if (option_debug)
1624                 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1625         return 0;
1626 }
1627
1628 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1629 {
1630         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1631         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1632         struct ast_rtp *tdestp = NULL, *tsrcp = NULL;           /* Text RTP channels */
1633         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1634         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;
1635         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; 
1636         int srccodec, destcodec;
1637
1638         /* Lock channels */
1639         ast_channel_lock(dest);
1640         while (ast_channel_trylock(src)) {
1641                 ast_channel_unlock(dest);
1642                 usleep(1);
1643                 ast_channel_lock(dest);
1644         }
1645
1646         /* Find channel driver interfaces */
1647         if (!(destpr = get_proto(dest))) {
1648                 if (option_debug)
1649                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1650                 ast_channel_unlock(dest);
1651                 ast_channel_unlock(src);
1652                 return 0;
1653         }
1654         if (!(srcpr = get_proto(src))) {
1655                 if (option_debug)
1656                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1657                 ast_channel_unlock(dest);
1658                 ast_channel_unlock(src);
1659                 return 0;
1660         }
1661
1662         /* Get audio and video interface (if native bridge is possible) */
1663         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1664         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1665         text_dest_res = destpr->get_trtp_info ? destpr->get_trtp_info(dest, &tdestp) : AST_RTP_GET_FAILED;
1666         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1667         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1668         text_src_res = srcpr->get_trtp_info ? srcpr->get_trtp_info(src, &tsrcp) : AST_RTP_GET_FAILED;
1669
1670         /* Ensure we have at least one matching codec */
1671         if (srcpr->get_codec)
1672                 srccodec = srcpr->get_codec(src);
1673         else
1674                 srccodec = 0;
1675         if (destpr->get_codec)
1676                 destcodec = destpr->get_codec(dest);
1677         else
1678                 destcodec = 0;
1679
1680         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1681         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE || !(srccodec & destcodec)) {
1682                 /* Somebody doesn't want to play... */
1683                 ast_channel_unlock(dest);
1684                 ast_channel_unlock(src);
1685                 return 0;
1686         }
1687         ast_rtp_pt_copy(destp, srcp);
1688         if (vdestp && vsrcp)
1689                 ast_rtp_pt_copy(vdestp, vsrcp);
1690         if (tdestp && tsrcp)
1691                 ast_rtp_pt_copy(tdestp, tsrcp);
1692         if (media) {
1693                 /* Bridge early */
1694                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, tsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1695                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1696         }
1697         ast_channel_unlock(dest);
1698         ast_channel_unlock(src);
1699         if (option_debug)
1700                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1701         return 1;
1702 }
1703
1704 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1705  * By default, use the well-known value for this type (although it may 
1706  * still be set to a different value by a subsequent "a=rtpmap:" line)
1707  */
1708 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1709 {
1710         if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) 
1711                 return; /* bogus payload type */
1712
1713         rtp_bridge_lock(rtp);
1714         rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1715         rtp_bridge_unlock(rtp);
1716
1717
1718 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1719  * an SDP "a=rtpmap:" line.
1720  */
1721 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1722                              char *mimeType, char *mimeSubtype,
1723                              enum ast_rtp_options options)
1724 {
1725         unsigned int i;
1726
1727         if (pt < 0 || pt > MAX_RTP_PT) 
1728                 return; /* bogus payload type */
1729         
1730         rtp_bridge_lock(rtp);
1731
1732         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1733                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1734                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1735                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1736                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1737                             mimeTypes[i].payloadType.isAstFormat &&
1738                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1739                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1740                         break;
1741                 }
1742         }
1743
1744         rtp_bridge_unlock(rtp);
1745
1746         return;
1747
1748
1749 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1750  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1751 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1752                                  int* astFormats, int* nonAstFormats)
1753 {
1754         int pt;
1755         
1756         rtp_bridge_lock(rtp);
1757         
1758         *astFormats = *nonAstFormats = 0;
1759         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1760                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1761                         *astFormats |= rtp->current_RTP_PT[pt].code;
1762                 } else {
1763                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1764                 }
1765         }
1766
1767         rtp_bridge_unlock(rtp);
1768         
1769         return;
1770 }
1771
1772 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1773 {
1774         struct rtpPayloadType result;
1775
1776         result.isAstFormat = result.code = 0;
1777
1778         if (pt < 0 || pt > MAX_RTP_PT) 
1779                 return result; /* bogus payload type */
1780
1781         /* Start with negotiated codecs */
1782         rtp_bridge_lock(rtp);
1783         result = rtp->current_RTP_PT[pt];
1784         rtp_bridge_unlock(rtp);
1785
1786         /* If it doesn't exist, check our static RTP type list, just in case */
1787         if (!result.code) 
1788                 result = static_RTP_PT[pt];
1789
1790         return result;
1791 }
1792
1793 /*! \brief Looks up an RTP code out of our *static* outbound list */
1794 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code)
1795 {
1796         int pt = 0;
1797
1798         rtp_bridge_lock(rtp);
1799
1800         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1801                 code == rtp->rtp_lookup_code_cache_code) {
1802                 /* Use our cached mapping, to avoid the overhead of the loop below */
1803                 pt = rtp->rtp_lookup_code_cache_result;
1804                 rtp_bridge_unlock(rtp);
1805                 return pt;
1806         }
1807
1808         /* Check the dynamic list first */
1809         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1810                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1811                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1812                         rtp->rtp_lookup_code_cache_code = code;
1813                         rtp->rtp_lookup_code_cache_result = pt;
1814                         rtp_bridge_unlock(rtp);
1815                         return pt;
1816                 }
1817         }
1818
1819         /* Then the static list */
1820         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1821                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1822                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1823                         rtp->rtp_lookup_code_cache_code = code;
1824                         rtp->rtp_lookup_code_cache_result = pt;
1825                         rtp_bridge_unlock(rtp);
1826                         return pt;
1827                 }
1828         }
1829
1830         rtp_bridge_unlock(rtp);
1831
1832         return -1;
1833 }
1834
1835 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1836                                   enum ast_rtp_options options)
1837 {
1838         unsigned int i;
1839
1840         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1841                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1842                         if (isAstFormat &&
1843                             (code == AST_FORMAT_G726_AAL2) &&
1844                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1845                                 return "G726-32";
1846                         else
1847                                 return mimeTypes[i].subtype;
1848                 }
1849         }
1850
1851         return "";
1852 }
1853
1854 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1855                                    const int isAstFormat, enum ast_rtp_options options)
1856 {
1857         int format;
1858         unsigned len;
1859         char *end = buf;
1860         char *start = buf;
1861
1862         if (!buf || !size)
1863                 return NULL;
1864
1865         snprintf(end, size, "0x%x (", capability);
1866
1867         len = strlen(end);
1868         end += len;
1869         size -= len;
1870         start = end;
1871
1872         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1873                 if (capability & format) {
1874                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1875
1876                         snprintf(end, size, "%s|", name);
1877                         len = strlen(end);
1878                         end += len;
1879                         size -= len;
1880                 }
1881         }
1882
1883         if (start == end)
1884                 snprintf(start, size, "nothing)"); 
1885         else if (size > 1)
1886                 *(end -1) = ')';
1887         
1888         return buf;
1889 }
1890
1891 /*! \brief Open RTP or RTCP socket for a session */
1892 static int rtp_socket(void)
1893 {
1894         int s;
1895         long flags;
1896         s = socket(AF_INET, SOCK_DGRAM, 0);
1897         if (s > -1) {
1898                 flags = fcntl(s, F_GETFL);
1899                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1900 #ifdef SO_NO_CHECK
1901                 if (nochecksums)
1902                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1903 #endif
1904         }
1905         return s;
1906 }
1907
1908 /*!
1909  * \brief Initialize a new RTCP session.
1910  * 
1911  * \returns The newly initialized RTCP session.
1912  */
1913 static struct ast_rtcp *ast_rtcp_new(void)
1914 {
1915         struct ast_rtcp *rtcp;
1916
1917         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1918                 return NULL;
1919         rtcp->s = rtp_socket();
1920         rtcp->us.sin_family = AF_INET;
1921         rtcp->them.sin_family = AF_INET;
1922
1923         if (rtcp->s < 0) {
1924                 free(rtcp);
1925                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1926                 return NULL;
1927         }
1928
1929         return rtcp;
1930 }
1931
1932 /*!
1933  * \brief Initialize a new RTP structure.
1934  *
1935  */
1936 void ast_rtp_new_init(struct ast_rtp *rtp)
1937 {
1938 #ifdef P2P_INTENSE
1939         ast_mutex_init(&rtp->bridge_lock);
1940 #endif
1941
1942         rtp->them.sin_family = AF_INET;
1943         rtp->us.sin_family = AF_INET;
1944         rtp->ssrc = ast_random();
1945         rtp->seqno = ast_random() & 0xffff;
1946         ast_set_flag(rtp, FLAG_HAS_DTMF);
1947
1948         return;
1949 }
1950
1951 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1952 {
1953         struct ast_rtp *rtp;
1954         int x;
1955         int first;
1956         int startplace;
1957         
1958         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1959                 return NULL;
1960
1961         ast_rtp_new_init(rtp);
1962
1963         rtp->s = rtp_socket();
1964         if (rtp->s < 0) {
1965                 free(rtp);
1966                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1967                 return NULL;
1968         }
1969         if (sched && rtcpenable) {
1970                 rtp->sched = sched;
1971                 rtp->rtcp = ast_rtcp_new();
1972         }
1973         
1974         /* Select a random port number in the range of possible RTP */
1975         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1976         x = x & ~1;
1977         /* Save it for future references. */
1978         startplace = x;
1979         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1980         for (;;) {
1981                 /* Must be an even port number by RTP spec */
1982                 rtp->us.sin_port = htons(x);
1983                 rtp->us.sin_addr = addr;
1984
1985                 /* If there's rtcp, initialize it as well. */
1986                 if (rtp->rtcp) {
1987                         rtp->rtcp->us.sin_port = htons(x + 1);
1988                         rtp->rtcp->us.sin_addr = addr;
1989                 }
1990                 /* Try to bind it/them. */
1991                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1992                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1993                         break;
1994                 if (!first) {
1995                         /* Primary bind succeeded! Gotta recreate it */
1996                         close(rtp->s);
1997                         rtp->s = rtp_socket();
1998                 }
1999                 if (errno != EADDRINUSE) {
2000                         /* We got an error that wasn't expected, abort! */
2001                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2002                         close(rtp->s);
2003                         if (rtp->rtcp) {
2004                                 close(rtp->rtcp->s);
2005                                 free(rtp->rtcp);
2006                         }
2007                         free(rtp);
2008                         return NULL;
2009                 }
2010                 /* The port was used, increment it (by two). */
2011                 x += 2;
2012                 /* Did we go over the limit ? */
2013                 if (x > rtpend)
2014                         /* then, start from the begingig. */
2015                         x = (rtpstart + 1) & ~1;
2016                 /* Check if we reached the place were we started. */
2017                 if (x == startplace) {
2018                         /* If so, there's no ports available. */
2019                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2020                         close(rtp->s);
2021                         if (rtp->rtcp) {
2022                                 close(rtp->rtcp->s);
2023                                 free(rtp->rtcp);
2024                         }
2025                         free(rtp);
2026                         return NULL;
2027                 }
2028         }
2029         rtp->sched = sched;
2030         rtp->io = io;
2031         if (callbackmode) {
2032                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2033                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
2034         }
2035         ast_rtp_pt_default(rtp);
2036         return rtp;
2037 }
2038
2039 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2040 {
2041         struct in_addr ia;
2042
2043         memset(&ia, 0, sizeof(ia));
2044         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2045 }
2046
2047 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
2048 {
2049         int res;
2050
2051         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
2052                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
2053         return res;
2054 }
2055
2056 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2057 {
2058         rtp->them.sin_port = them->sin_port;
2059         rtp->them.sin_addr = them->sin_addr;
2060         if (rtp->rtcp) {
2061                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2062                 rtp->rtcp->them.sin_addr = them->sin_addr;
2063         }
2064         rtp->rxseqno = 0;
2065 }
2066
2067 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2068 {
2069         if ((them->sin_family != AF_INET) ||
2070                 (them->sin_port != rtp->them.sin_port) ||
2071                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2072                 them->sin_family = AF_INET;
2073                 them->sin_port = rtp->them.sin_port;
2074                 them->sin_addr = rtp->them.sin_addr;
2075                 return 1;
2076         }
2077         return 0;
2078 }
2079
2080 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2081 {
2082         *us = rtp->us;
2083 }
2084
2085 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2086 {
2087         struct ast_rtp *bridged = NULL;
2088
2089         rtp_bridge_lock(rtp);
2090         bridged = rtp->bridged;
2091         rtp_bridge_unlock(rtp);
2092
2093         return bridged;
2094 }
2095
2096 void ast_rtp_stop(struct ast_rtp *rtp)
2097 {
2098         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2099                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2100                 rtp->rtcp->schedid = -1;
2101         }
2102
2103         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2104         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2105         if (rtp->rtcp) {
2106                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2107                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2108         }
2109         
2110         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2111 }
2112
2113 void ast_rtp_reset(struct ast_rtp *rtp)
2114 {
2115         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2116         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2117         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2118         rtp->lastts = 0;
2119         rtp->lastdigitts = 0;
2120         rtp->lastrxts = 0;
2121         rtp->lastividtimestamp = 0;
2122         rtp->lastovidtimestamp = 0;
2123         rtp->lastitexttimestamp = 0;
2124         rtp->lastotexttimestamp = 0;
2125         rtp->lasteventseqn = 0;
2126         rtp->lastevent = 0;
2127         rtp->lasttxformat = 0;
2128         rtp->lastrxformat = 0;
2129         rtp->dtmfcount = 0;
2130         rtp->dtmfsamples = 0;
2131         rtp->seqno = 0;
2132         rtp->rxseqno = 0;
2133 }
2134
2135 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2136 {
2137         /*
2138         *ssrc          our ssrc
2139         *themssrc      their ssrc
2140         *lp            lost packets
2141         *rxjitter      our calculated jitter(rx)
2142         *rxcount       no. received packets
2143         *txjitter      reported jitter of the other end
2144         *txcount       transmitted packets
2145         *rlp           remote lost packets
2146         *rtt           round trip time
2147         */
2148
2149         if (qual) {
2150                 qual->local_ssrc = rtp->ssrc;
2151                 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2152                 qual->local_jitter = rtp->rxjitter;
2153                 qual->local_count = rtp->rxcount;
2154                 qual->remote_ssrc = rtp->themssrc;
2155                 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2156                 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2157                 qual->remote_count = rtp->txcount;
2158                 qual->rtt = rtp->rtcp->rtt;
2159         }
2160         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);
2161         
2162         return rtp->rtcp->quality;
2163 }
2164
2165 void ast_rtp_destroy(struct ast_rtp *rtp)
2166 {
2167         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2168                 /*Print some info on the call here */
2169                 ast_verbose("  RTP-stats\n");
2170                 ast_verbose("* Our Receiver:\n");
2171                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2172                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2173                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2174                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2175                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2176                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2177                 ast_verbose("* Our Sender:\n");
2178                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2179                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2180                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2181                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2182                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2183                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2184         }
2185
2186         if (rtp->smoother)
2187                 ast_smoother_free(rtp->smoother);
2188         if (rtp->ioid)
2189                 ast_io_remove(rtp->io, rtp->ioid);
2190         if (rtp->s > -1)
2191                 close(rtp->s);
2192         if (rtp->rtcp) {
2193                 if (rtp->rtcp->schedid > 0)
2194                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2195                 close(rtp->rtcp->s);
2196                 free(rtp->rtcp);
2197                 rtp->rtcp=NULL;
2198         }
2199 #ifdef P2P_INTENSE
2200         ast_mutex_destroy(&rtp->bridge_lock);
2201 #endif
2202         free(rtp);
2203 }
2204
2205 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2206 {
2207         struct timeval t;
2208         long ms;
2209         if (ast_tvzero(rtp->txcore)) {
2210                 rtp->txcore = ast_tvnow();
2211                 /* Round to 20ms for nice, pretty timestamps */
2212                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2213         }
2214         /* Use previous txcore if available */
2215         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2216         ms = ast_tvdiff_ms(t, rtp->txcore);
2217         if (ms < 0)
2218                 ms = 0;
2219         /* Use what we just got for next time */
2220         rtp->txcore = t;
2221         return (unsigned int) ms;
2222 }
2223
2224 /*! \brief Send begin frames for DTMF */
2225 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2226 {
2227         unsigned int *rtpheader;
2228         int hdrlen = 12, res = 0, i = 0, payload = 0;
2229         char data[256];
2230
2231         if ((digit <= '9') && (digit >= '0'))
2232                 digit -= '0';
2233         else if (digit == '*')
2234                 digit = 10;
2235         else if (digit == '#')
2236                 digit = 11;
2237         else if ((digit >= 'A') && (digit <= 'D'))
2238                 digit = digit - 'A' + 12;
2239         else if ((digit >= 'a') && (digit <= 'd'))
2240                 digit = digit - 'a' + 12;
2241         else {
2242                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2243                 return 0;
2244         }
2245
2246         /* If we have no peer, return immediately */    
2247         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2248                 return 0;
2249
2250         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2251
2252         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2253         rtp->send_duration = 160;
2254         
2255         /* Get a pointer to the header */
2256         rtpheader = (unsigned int *)data;
2257         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2258         rtpheader[1] = htonl(rtp->lastdigitts);
2259         rtpheader[2] = htonl(rtp->ssrc); 
2260
2261         for (i = 0; i < 2; i++) {
2262                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2263                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2264                 if (res < 0) 
2265                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2266                                 ast_inet_ntoa(rtp->them.sin_addr),
2267                                 ntohs(rtp->them.sin_port), strerror(errno));
2268                 if (rtp_debug_test_addr(&rtp->them))
2269                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2270                                     ast_inet_ntoa(rtp->them.sin_addr),
2271                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2272                 /* Increment sequence number */
2273                 rtp->seqno++;
2274                 /* Increment duration */
2275                 rtp->send_duration += 160;
2276                 /* Clear marker bit and set seqno */
2277                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2278         }
2279
2280         /* Since we received a begin, we can safely store the digit and disable any compensation */
2281         rtp->sending_digit = 1;
2282         rtp->send_digit = digit;
2283         rtp->send_payload = payload;
2284
2285         return 0;
2286 }
2287
2288 /*! \brief Send continuation frame for DTMF */
2289 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2290 {
2291         unsigned int *rtpheader;
2292         int hdrlen = 12, res = 0;
2293         char data[256];
2294
2295         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2296                 return 0;
2297
2298         /* Setup packet to send */
2299         rtpheader = (unsigned int *)data;
2300         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2301         rtpheader[1] = htonl(rtp->lastdigitts);
2302         rtpheader[2] = htonl(rtp->ssrc);
2303         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2304         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2305         
2306         /* Transmit */
2307         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2308         if (res < 0)
2309                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2310                         ast_inet_ntoa(rtp->them.sin_addr),
2311                         ntohs(rtp->them.sin_port), strerror(errno));
2312         if (rtp_debug_test_addr(&rtp->them))
2313                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2314                             ast_inet_ntoa(rtp->them.sin_addr),
2315                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2316
2317         /* Increment sequence number */
2318         rtp->seqno++;
2319         /* Increment duration */
2320         rtp->send_duration += 160;
2321
2322         return 0;
2323 }
2324
2325 /*! \brief Send end packets for DTMF */
2326 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2327 {
2328         unsigned int *rtpheader;
2329         int hdrlen = 12, res = 0, i = 0;
2330         char data[256];
2331         
2332         /* If no address, then bail out */
2333         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2334                 return 0;
2335         
2336         if ((digit <= '9') && (digit >= '0'))
2337                 digit -= '0';
2338         else if (digit == '*')
2339                 digit = 10;
2340         else if (digit == '#')
2341                 digit = 11;
2342         else if ((digit >= 'A') && (digit <= 'D'))
2343                 digit = digit - 'A' + 12;
2344         else if ((digit >= 'a') && (digit <= 'd'))
2345                 digit = digit - 'a' + 12;
2346         else {
2347                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2348                 return 0;
2349         }
2350
2351         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2352
2353         rtpheader = (unsigned int *)data;
2354         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2355         rtpheader[1] = htonl(rtp->lastdigitts);
2356         rtpheader[2] = htonl(rtp->ssrc);
2357         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2358         /* Set end bit */
2359         rtpheader[3] |= htonl((1 << 23));
2360         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2361         /* Send 3 termination packets */
2362         for (i = 0; i < 3; i++) {
2363                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2364                 if (res < 0)
2365                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2366                                 ast_inet_ntoa(rtp->them.sin_addr),
2367                                 ntohs(rtp->them.sin_port), strerror(errno));
2368                 if (rtp_debug_test_addr(&rtp->them))
2369                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2370                                     ast_inet_ntoa(rtp->them.sin_addr),
2371                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2372         }
2373         rtp->sending_digit = 0;
2374         rtp->send_digit = 0;
2375         /* Increment lastdigitts */
2376         rtp->lastdigitts += 960;
2377         rtp->seqno++;
2378
2379         return res;
2380 }
2381
2382 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2383 int ast_rtcp_send_h261fur(void *data)
2384 {
2385         struct ast_rtp *rtp = data;
2386         int res;
2387
2388         rtp->rtcp->sendfur = 1;
2389         res = ast_rtcp_write(data);
2390         
2391         return res;
2392 }
2393
2394 /*! \brief Send RTCP sender's report */
2395 static int ast_rtcp_write_sr(void *data)
2396 {
2397         struct ast_rtp *rtp = data;
2398         int res;
2399         int len = 0;
2400         struct timeval now;
2401         unsigned int now_lsw;
2402         unsigned int now_msw;
2403         unsigned int *rtcpheader;
2404         unsigned int lost;
2405         unsigned int extended;
2406         unsigned int expected;
2407         unsigned int expected_interval;
2408         unsigned int received_interval;
2409         int lost_interval;
2410         int fraction;
2411         struct timeval dlsr;
2412         char bdata[512];
2413
2414         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2415         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2416                 return 0;
2417         
2418         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2419                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2420                 if (rtp->rtcp->schedid > 0)
2421                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2422                 rtp->rtcp->schedid = -1;
2423                 return 0;
2424         }
2425
2426         gettimeofday(&now, NULL);
2427         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2428         rtcpheader = (unsigned int *)bdata;
2429         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2430         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2431         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2432         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2433         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2434         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2435         len += 28;
2436         
2437         extended = rtp->cycles + rtp->lastrxseqno;
2438         expected = extended - rtp->seedrxseqno + 1;
2439         if (rtp->rxcount > expected) 
2440                 expected += rtp->rxcount - expected;
2441         lost = expected - rtp->rxcount;
2442         expected_interval = expected - rtp->rtcp->expected_prior;
2443         rtp->rtcp->expected_prior = expected;
2444         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2445         rtp->rtcp->received_prior = rtp->rxcount;
2446         lost_interval = expected_interval - received_interval;
2447         if (expected_interval == 0 || lost_interval <= 0)
2448                 fraction = 0;
2449         else
2450                 fraction = (lost_interval << 8) / expected_interval;
2451         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2452         rtcpheader[7] = htonl(rtp->themssrc);
2453         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2454         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2455         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2456         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2457         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2458         len += 24;
2459         
2460         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2461
2462         if (rtp->rtcp->sendfur) {
2463                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2464                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2465                 len += 8;
2466                 rtp->rtcp->sendfur = 0;
2467         }
2468         
2469         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2470         /* it can change mid call, and SDES can't) */
2471         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2472         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2473         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2474         len += 12;
2475         
2476         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2477         if (res < 0) {
2478                 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));
2479                 if (rtp->rtcp->schedid > 0)
2480                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2481                 rtp->rtcp->schedid = -1;
2482                 return 0;
2483         }
2484         
2485         /* FIXME Don't need to get a new one */
2486         gettimeofday(&rtp->rtcp->txlsr, NULL);
2487         rtp->rtcp->sr_count++;
2488
2489         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2490         
2491         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2492                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2493                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2494                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2495                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2496                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2497                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2498                 ast_verbose("  Report block:\n");
2499                 ast_verbose("  Fraction lost: %u\n", fraction);
2500                 ast_verbose("  Cumulative loss: %u\n", lost);
2501                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2502                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2503                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2504         }
2505         return res;
2506 }
2507
2508 /*! \brief Send RTCP recipient's report */
2509 static int ast_rtcp_write_rr(void *data)
2510 {
2511         struct ast_rtp *rtp = data;
2512         int res;
2513         int len = 32;
2514         unsigned int lost;
2515         unsigned int extended;
2516         unsigned int expected;
2517         unsigned int expected_interval;
2518         unsigned int received_interval;
2519         int lost_interval;
2520         struct timeval now;
2521         unsigned int *rtcpheader;
2522         char bdata[1024];
2523         struct timeval dlsr;
2524         int fraction;
2525
2526         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2527                 return 0;
2528           
2529         if (!rtp->rtcp->them.sin_addr.s_addr) {
2530                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2531                 if (rtp->rtcp->schedid > 0)
2532                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2533                 rtp->rtcp->schedid = -1;
2534                 return 0;
2535         }
2536
2537         extended = rtp->cycles + rtp->lastrxseqno;
2538         expected = extended - rtp->seedrxseqno + 1;
2539         lost = expected - rtp->rxcount;
2540         expected_interval = expected - rtp->rtcp->expected_prior;
2541         rtp->rtcp->expected_prior = expected;
2542         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2543         rtp->rtcp->received_prior = rtp->rxcount;
2544         lost_interval = expected_interval - received_interval;
2545         if (expected_interval == 0 || lost_interval <= 0)
2546                 fraction = 0;
2547         else
2548                 fraction = (lost_interval << 8) / expected_interval;
2549         gettimeofday(&now, NULL);
2550         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2551         rtcpheader = (unsigned int *)bdata;
2552         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2553         rtcpheader[1] = htonl(rtp->ssrc);
2554         rtcpheader[2] = htonl(rtp->themssrc);
2555         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2556         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2557         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2558         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2559         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2560
2561         if (rtp->rtcp->sendfur) {
2562                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2563                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2564                 len += 8;
2565                 rtp->rtcp->sendfur = 0;
2566         }
2567
2568         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2569         it can change mid call, and SDES can't) */
2570         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2571         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2572         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2573         len += 12;
2574         
2575         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2576
2577         if (res < 0) {
2578                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2579                 /* Remove the scheduler */
2580                 if (rtp->rtcp->schedid > 0)
2581                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2582                 rtp->rtcp->schedid = -1;
2583                 return 0;
2584         }
2585
2586         rtp->rtcp->rr_count++;
2587
2588         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2589                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2590                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2591                         "  IA jitter: %.4f\n" 
2592                         "  Their last SR: %u\n" 
2593                         "  DLSR: %4.4f (sec)\n\n",
2594                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2595                         ntohs(rtp->rtcp->them.sin_port),
2596                         rtp->ssrc, rtp->themssrc, fraction, lost,
2597                         rtp->rxjitter,
2598                         rtp->rtcp->themrxlsr,
2599                         (double)(ntohl(rtcpheader[7])/65536.0));
2600         }
2601
2602         return res;
2603 }
2604
2605 /*! \brief Write and RTCP packet to the far end
2606  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2607  * RR is sent if we have not sent any rtp packets in the previous interval */
2608 static int ast_rtcp_write(void *data)
2609 {
2610         struct ast_rtp *rtp = data;
2611         int res;
2612         
2613         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2614                 res = ast_rtcp_write_sr(data);
2615         else
2616                 res = ast_rtcp_write_rr(data);
2617         
2618         return res;
2619 }
2620
2621 /*! \brief generate comfort noice (CNG) */
2622 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2623 {
2624         unsigned int *rtpheader;
2625         int hdrlen = 12;
2626         int res;
2627         int payload;
2628         char data[256];
2629         level = 127 - (level & 0x7f);
2630         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2631
2632         /* If we have no peer, return immediately */    
2633         if (!rtp->them.sin_addr.s_addr)
2634                 return 0;
2635
2636         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2637
2638         /* Get a pointer to the header */
2639         rtpheader = (unsigned int *)data;
2640         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2641         rtpheader[1] = htonl(rtp->lastts);
2642         rtpheader[2] = htonl(rtp->ssrc); 
2643         data[12] = level;
2644         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2645                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2646                 if (res <0) 
2647                         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));
2648                 if (rtp_debug_test_addr(&rtp->them))
2649                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2650                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2651                    
2652         }
2653         return 0;
2654 }
2655
2656 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2657 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2658 {
2659         unsigned char *rtpheader;
2660         int hdrlen = 12;
2661         int res;
2662         unsigned int ms;
2663         int pred;
2664         int mark = 0;
2665
2666         ms = calc_txstamp(rtp, &f->delivery);
2667         /* Default prediction */
2668         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2669                 pred = rtp->lastts + f->samples;
2670
2671                 /* Re-calculate last TS */
2672                 rtp->lastts = rtp->lastts + ms * 8;
2673                 if (ast_tvzero(f->delivery)) {
2674                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2675                            and if so, go with our prediction */
2676                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2677                                 rtp->lastts = pred;
2678                         else {
2679                                 if (option_debug > 2)
2680                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2681                                 mark = 1;
2682                         }
2683                 }
2684         } else if(f->subclass < AST_FORMAT_MAX_VIDEO) {
2685                 mark = f->subclass & 0x1;
2686                 pred = rtp->lastovidtimestamp + f->samples;
2687                 /* Re-calculate last TS */
2688                 rtp->lastts = rtp->lastts + ms * 90;
2689                 /* If it's close to our prediction, go for it */
2690                 if (ast_tvzero(f->delivery)) {
2691                         if (abs(rtp->lastts - pred) < 7200) {
2692                                 rtp->lastts = pred;
2693                                 rtp->lastovidtimestamp += f->samples;
2694                         } else {
2695                                 if (option_debug > 2)
2696                                         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);
2697                                 rtp->lastovidtimestamp = rtp->lastts;
2698                         }
2699                 }
2700         } else {
2701                 pred = rtp->lastotexttimestamp + f->samples;
2702                 /* Re-calculate last TS */
2703                 rtp->lastts = rtp->lastts + ms * 90;
2704                 /* If it's close to our prediction, go for it */
2705                 if (ast_tvzero(f->delivery)) {
2706                         if (abs(rtp->lastts - pred) < 7200) {
2707                                 rtp->lastts = pred;
2708                                 rtp->lastotexttimestamp += f->samples;
2709                         } else {
2710                                 if (option_debug > 2)
2711                                         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);
2712                                 rtp->lastotexttimestamp = rtp->lastts;
2713                         }
2714                 }
2715         }
2716         /* If the timestamp for non-digit packets has moved beyond the timestamp
2717            for digits, update the digit timestamp.
2718         */
2719         if (rtp->lastts > rtp->lastdigitts)
2720                 rtp->lastdigitts = rtp->lastts;
2721
2722         if (f->has_timing_info)
2723                 rtp->lastts = f->ts * 8;
2724
2725         /* Get a pointer to the header */
2726         rtpheader = (unsigned char *)(f->data - hdrlen);
2727
2728         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2729         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2730         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2731
2732         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2733                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2734                 if (res <0) {
2735                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2736                                 if (option_debug)
2737                                         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));
2738                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2739                                 /* Only give this error message once if we are not RTP debugging */
2740                                 if (option_debug || rtpdebug)
2741                                         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));
2742                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2743                         }
2744                 } else {
2745                         rtp->txcount++;
2746                         rtp->txoctetcount +=(res - hdrlen);
2747                         
2748                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2749                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2750                 }
2751                                 
2752                 if (rtp_debug_test_addr(&rtp->them))
2753                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2754                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2755         }
2756
2757         rtp->seqno++;
2758
2759         return 0;
2760 }
2761
2762 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2763 {
2764         int x;
2765         for (x = 0; x < 32; x++) {  /* Ugly way */
2766                 rtp->pref.order[x] = prefs->order[x];
2767                 rtp->pref.framing[x] = prefs->framing[x];
2768         }
2769         if (rtp->smoother)
2770                 ast_smoother_free(rtp->smoother);
2771         rtp->smoother = NULL;
2772         return 0;
2773 }
2774
2775 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2776 {
2777         return &rtp->pref;
2778 }
2779
2780 int ast_rtp_codec_getformat(int pt)
2781 {
2782         if (pt < 0 || pt > MAX_RTP_PT)
2783                 return 0; /* bogus payload type */
2784
2785         if (static_RTP_PT[pt].isAstFormat)
2786                 return static_RTP_PT[pt].code;
2787         else
2788                 return 0;
2789 }
2790
2791 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2792 {
2793         struct ast_frame *f;
2794         int codec;
2795         int hdrlen = 12;
2796         int subclass;
2797         
2798
2799         /* If we have no peer, return immediately */    
2800         if (!rtp->them.sin_addr.s_addr)
2801                 return 0;
2802
2803         /* If there is no data length, return immediately */
2804         if (!_f->datalen) 
2805                 return 0;
2806         
2807         /* Make sure we have enough space for RTP header */
2808         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
2809                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
2810                 return -1;
2811         }
2812
2813         /* The bottom bit of a video subclass contains the marker bit */
2814         subclass = _f->subclass;
2815         if (_f->frametype == AST_FRAME_VIDEO)
2816                 subclass &= ~0x1;
2817
2818         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2819         if (codec < 0) {
2820                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2821                 return -1;
2822         }
2823
2824         if (rtp->lasttxformat != subclass) {
2825                 /* New format, reset the smoother */
2826                 if (option_debug)
2827                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2828                 rtp->lasttxformat = subclass;
2829                 if (rtp->smoother)
2830                         ast_smoother_free(rtp->smoother);
2831                 rtp->smoother = NULL;
2832         }
2833
2834         if (!rtp->smoother) {
2835                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2836                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2837                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2838                                 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));
2839                                 return -1;
2840                         }
2841                         if (fmt.flags)
2842                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2843                         if (option_debug)
2844                                 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));
2845                 }
2846         }
2847         if (rtp->smoother) {
2848                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2849                         ast_smoother_feed_be(rtp->smoother, _f);
2850                 } else {
2851                         ast_smoother_feed(rtp->smoother, _f);
2852                 }
2853
2854                 while ((f = ast_smoother_read(rtp->smoother)))
2855                         ast_rtp_raw_write(rtp, f, codec);
2856         } else {
2857                 /* Don't buffer outgoing frames; send them one-per-packet: */
2858                 if (_f->offset < hdrlen) 
2859                         f = ast_frdup(_f);      /*! \bug XXX this might never be free'd. Why do we do this? */
2860                 else
2861                         f = _f;
2862                 ast_rtp_raw_write(rtp, f, codec);
2863                 if (f != _f)
2864                         ast_frfree(f);
2865         }
2866                 
2867         return 0;
2868 }
2869
2870 /*! \brief Unregister interface to channel driver */
2871 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2872 {
2873         AST_RWLIST_WRLOCK(&protos);
2874         AST_RWLIST_REMOVE(&protos, proto, list);
2875         AST_RWLIST_UNLOCK(&protos);
2876 }
2877
2878 /*! \brief Register interface to channel driver */
2879 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2880 {
2881         struct ast_rtp_protocol *cur;
2882
2883         AST_RWLIST_WRLOCK(&protos);
2884         AST_RWLIST_TRAVERSE(&protos, cur, list) {       
2885                 if (!strcmp(cur->type, proto->type)) {
2886                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2887                         AST_RWLIST_UNLOCK(&protos);
2888                         return -1;
2889                 }
2890         }
2891         AST_RWLIST_INSERT_HEAD(&protos, proto, list);
2892         AST_RWLIST_UNLOCK(&protos);
2893         
2894         return 0;
2895 }
2896
2897 /*! \brief Bridge loop for true native bridge (reinvite) */
2898 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)
2899 {
2900         struct ast_frame *fr = NULL;
2901         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2902         int oldcodec0 = codec0, oldcodec1 = codec1;
2903         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
2904         struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
2905         
2906         /* Set it up so audio goes directly between the two endpoints */
2907
2908         /* Test the first channel */
2909         if (!(pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2910                 ast_rtp_get_peer(p1, &ac1);
2911                 if (vp1)
2912                         ast_rtp_get_peer(vp1, &vac1);
2913                 if (tp1)
2914                         ast_rtp_get_peer(tp1, &tac1);
2915         } else
2916                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2917         
2918         /* Test the second channel */
2919         if (!(pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2920                 ast_rtp_get_peer(p0, &ac0);
2921                 if (vp0)
2922                         ast_rtp_get_peer(vp0, &vac0);
2923                 if (tp0)
2924                         ast_rtp_get_peer(tp0, &tac0);
2925         } else
2926                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2927
2928         /* Now we can unlock and move into our loop */
2929         ast_channel_unlock(c0);
2930         ast_channel_unlock(c1);
2931
2932         /* Throw our channels into the structure and enter the loop */
2933         cs[0] = c0;
2934         cs[1] = c1;
2935         cs[2] = NULL;
2936         for (;;) {
2937                 /* Check if anything changed */
2938                 if ((c0->tech_pvt != pvt0) ||
2939                     (c1->tech_pvt != pvt1) ||
2940                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2941                         if (option_debug)
2942                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2943                         if (c0->tech_pvt == pvt0)
2944                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
2945                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2946                         if (c1->tech_pvt == pvt1)
2947                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
2948                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2949                         return AST_BRIDGE_RETRY;
2950                 }
2951
2952                 /* Check if they have changed their address */
2953                 ast_rtp_get_peer(p1, &t1);
2954                 if (vp1)
2955                         ast_rtp_get_peer(vp1, &vt1);
2956                 if (tp1)
2957                         ast_rtp_get_peer(tp1, &tt1);
2958                 if (pr1->get_codec)
2959                         codec1 = pr1->get_codec(c1);
2960                 ast_rtp_get_peer(p0, &t0);
2961                 if (vp0)
2962                         ast_rtp_get_peer(vp0, &vt0);
2963                 if (tp0)
2964                         ast_rtp_get_peer(tp0, &tt0);
2965                 if (pr0->get_codec)
2966                         codec0 = pr0->get_codec(c0);
2967                 if ((inaddrcmp(&t1, &ac1)) ||
2968                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2969                     (tp1 && inaddrcmp(&tt1, &tac1)) ||
2970                     (codec1 != oldcodec1)) {
2971                         if (option_debug > 1) {
2972                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2973                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2974                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2975                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2976                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
2977                                         c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
2978                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2979                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2980                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2981                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2982                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2983                                         c1->name, ast_inet_ntoa(tac1.sin_addr), ntohs(tac1.sin_port), oldcodec1);
2984                         }
2985                         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)))
2986                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2987                         memcpy(&ac1, &t1, sizeof(ac1));
2988                         memcpy(&vac1, &vt1, sizeof(vac1));
2989                         memcpy(&tac1, &tt1, sizeof(tac1));
2990                         oldcodec1 = codec1;
2991                 }
2992                 if ((inaddrcmp(&t0, &ac0)) ||
2993                     (vp0 && inaddrcmp(&vt0, &vac0)) ||
2994                     (tp0 && inaddrcmp(&tt0, &tac0))) {
2995                         if (option_debug > 1) {
2996                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2997                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2998                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2999                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
3000                         }
3001                         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)))
3002                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
3003                         memcpy(&ac0, &t0, sizeof(ac0));
3004                         memcpy(&vac0, &vt0, sizeof(vac0));
3005                         memcpy(&tac0, &tt0, sizeof(tac0));
3006                         oldcodec0 = codec0;
3007                 }
3008
3009                 /* Wait for frame to come in on the channels */
3010                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
3011                         if (!timeoutms)
3012                                 return AST_BRIDGE_RETRY;
3013                         if (option_debug)
3014                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
3015                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3016                                 break;
3017                         continue;
3018                 }
3019                 fr = ast_read(who);
3020                 other = (who == c0) ? c1 : c0;
3021                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3022                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
3023                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
3024                         /* Break out of bridge */
3025                         *fo = fr;
3026                         *rc = who;
3027                         if (option_debug)
3028                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3029                         if (c0->tech_pvt == pvt0)
3030                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3031                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3032                         if (c1->tech_pvt == pvt1)
3033                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3034                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3035                         return AST_BRIDGE_COMPLETE;
3036                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3037                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3038                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3039                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3040                                 if (fr->subclass == AST_CONTROL_HOLD) {
3041                                         /* If we someone went on hold we want the other side to reinvite back to us */
3042                                         if (who == c0)
3043                                                 pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0);
3044                                         else
3045                                                 pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0);
3046                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3047                                         /* If they went off hold they should go back to being direct */
3048                                         if (who == c0)
3049                                                 pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE));
3050                                         else
3051                                                 pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE));
3052                                 }
3053                                 ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
3054                                 ast_frfree(fr);
3055                         } else {
3056                                 *fo = fr;
3057                                 *rc = who;
3058                                 if (option_debug)
3059                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3060                                 return AST_BRIDGE_COMPLETE;
3061                         }
3062                 } else {
3063                         if ((fr->frametype == AST_FRAME_DTMF_BEGIN) ||
3064                             (fr->frametype == AST_FRAME_DTMF) ||
3065                             (fr->frametype == AST_FRAME_VOICE) ||
3066                             (fr->frametype == AST_FRAME_VIDEO) ||
3067                             (fr->frametype == AST_FRAME_IMAGE) ||
3068                             (fr->frametype == AST_FRAME_HTML) ||
3069                             (fr->frametype == AST_FRAME_MODEM) ||
3070                             (fr->frametype == AST_FRAME_TEXT)) {
3071                                 ast_write(other, fr);
3072                         }
3073                         ast_frfree(fr);
3074                 }
3075                 /* Swap priority */
3076                 cs[2] = cs[0];
3077                 cs[0] = cs[1];
3078                 cs[1] = cs[2];
3079         }
3080
3081         return AST_BRIDGE_FAILED;
3082 }
3083
3084 /*! \brief P2P RTP Callback */
3085 #ifdef P2P_INTENSE
3086 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
3087 {
3088         int res = 0, hdrlen = 12;
3089         struct sockaddr_in sin;
3090         socklen_t len;
3091         unsigned int *header;
3092         struct ast_rtp *rtp = cbdata, *bridged = NULL;
3093
3094         if (!rtp)
3095                 return 1;
3096
3097         len = sizeof(sin);
3098         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
3099                 return 1;
3100
3101         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
3102         
3103         /* If NAT support is turned on, then see if we need to change their address */
3104         if ((rtp->nat) && 
3105             ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
3106              (rtp->them.sin_port != sin.sin_port))) {
3107                 rtp->them = sin;
3108                 rtp->rxseqno = 0;
3109                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
3110                 if (option_debug || rtpdebug)
3111                         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));
3112         }
3113
3114         /* Write directly out to other RTP stream if bridged */
3115         if ((bridged = ast_rtp_get_bridged(rtp)))
3116                 bridge_p2p_rtp_write(rtp, bridged, header, res, hdrlen);
3117         
3118         return 1;
3119 }
3120
3121 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3122 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3123 {
3124         /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3125         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || ast_test_flag(rtp, FLAG_HAS_STUN) || !rtp->io)
3126                 return 0;
3127
3128         /* If the RTP structure is already in callback mode, remove it temporarily */
3129         if (rtp->ioid) {
3130                 ast_io_remove(rtp->io, rtp->ioid);
3131                 rtp->ioid = NULL;
3132         }
3133
3134         /* Steal the file descriptors from the channel */
3135         chan->fds[0] = -1;
3136
3137         /* Now, fire up callback mode */
3138         iod[0] = ast_io_add(rtp->io, ast_rtp_fd(rtp), p2p_rtp_callback, AST_IO_IN, rtp);
3139
3140         return 1;
3141 }
3142 #else
3143 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3144 {
3145         return 0;
3146 }
3147 #endif
3148
3149 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3150 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
3151 {
3152         ast_channel_lock(chan);
3153
3154         /* Remove the callback from the IO context */
3155         ast_io_remove(rtp->io, iod[0]);
3156
3157         /* Restore file descriptors */
3158         chan->fds[0] = ast_rtp_fd(rtp);
3159         ast_channel_unlock(chan);
3160
3161         /* Restore callback mode if previously used */
3162         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
3163                 rtp->ioid = ast_io_add(rtp->io, ast_rtp_fd(rtp), rtpread, AST_IO_IN, rtp);
3164
3165         return 0;
3166 }
3167
3168 /*! \brief Helper function that sets what an RTP structure is bridged to */
3169 static void p2p_set_bridge(struct ast_rtp *rtp0, struct ast_rtp *rtp1)
3170 {
3171         rtp_bridge_lock(rtp0);
3172         rtp0->bridged = rtp1;
3173         rtp_bridge_unlock(rtp0);
3174
3175         return;
3176 }
3177
3178 /*! \brief Bridge loop for partial native bridge (packet2packet) 
3179
3180