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