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