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