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