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