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