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