add a bit of documentation on what the stun code in rtp.c does
[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 static int rtp_socket(void)
2008 {
2009         int s;
2010         long flags;
2011         s = socket(AF_INET, SOCK_DGRAM, 0);
2012         if (s > -1) {
2013                 flags = fcntl(s, F_GETFL);
2014                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
2015 #ifdef SO_NO_CHECK
2016                 if (nochecksums)
2017                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
2018 #endif
2019         }
2020         return s;
2021 }
2022
2023 /*!
2024  * \brief Initialize a new RTCP session.
2025  * 
2026  * \returns The newly initialized RTCP session.
2027  */
2028 static struct ast_rtcp *ast_rtcp_new(void)
2029 {
2030         struct ast_rtcp *rtcp;
2031
2032         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
2033                 return NULL;
2034         rtcp->s = rtp_socket();
2035         rtcp->us.sin_family = AF_INET;
2036         rtcp->them.sin_family = AF_INET;
2037
2038         if (rtcp->s < 0) {
2039                 ast_free(rtcp);
2040                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
2041                 return NULL;
2042         }
2043
2044         return rtcp;
2045 }
2046
2047 /*!
2048  * \brief Initialize a new RTP structure.
2049  *
2050  */
2051 void ast_rtp_new_init(struct ast_rtp *rtp)
2052 {
2053 #ifdef P2P_INTENSE
2054         ast_mutex_init(&rtp->bridge_lock);
2055 #endif
2056
2057         rtp->them.sin_family = AF_INET;
2058         rtp->us.sin_family = AF_INET;
2059         rtp->ssrc = ast_random();
2060         rtp->seqno = ast_random() & 0xffff;
2061         ast_set_flag(rtp, FLAG_HAS_DTMF);
2062
2063         return;
2064 }
2065
2066 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
2067 {
2068         struct ast_rtp *rtp;
2069         int x;
2070         int first;
2071         int startplace;
2072         
2073         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
2074                 return NULL;
2075
2076         ast_rtp_new_init(rtp);
2077
2078         rtp->s = rtp_socket();
2079         if (rtp->s < 0) {
2080                 ast_free(rtp);
2081                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
2082                 return NULL;
2083         }
2084         if (sched && rtcpenable) {
2085                 rtp->sched = sched;
2086                 rtp->rtcp = ast_rtcp_new();
2087         }
2088         
2089         /* Select a random port number in the range of possible RTP */
2090         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
2091         x = x & ~1;
2092         /* Save it for future references. */
2093         startplace = x;
2094         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
2095         for (;;) {
2096                 /* Must be an even port number by RTP spec */
2097                 rtp->us.sin_port = htons(x);
2098                 rtp->us.sin_addr = addr;
2099
2100                 /* If there's rtcp, initialize it as well. */
2101                 if (rtp->rtcp) {
2102                         rtp->rtcp->us.sin_port = htons(x + 1);
2103                         rtp->rtcp->us.sin_addr = addr;
2104                 }
2105                 /* Try to bind it/them. */
2106                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
2107                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
2108                         break;
2109                 if (!first) {
2110                         /* Primary bind succeeded! Gotta recreate it */
2111                         close(rtp->s);
2112                         rtp->s = rtp_socket();
2113                 }
2114                 if (errno != EADDRINUSE) {
2115                         /* We got an error that wasn't expected, abort! */
2116                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
2117                         close(rtp->s);
2118                         if (rtp->rtcp) {
2119                                 close(rtp->rtcp->s);
2120                                 ast_free(rtp->rtcp);
2121                         }
2122                         ast_free(rtp);
2123                         return NULL;
2124                 }
2125                 /* The port was used, increment it (by two). */
2126                 x += 2;
2127                 /* Did we go over the limit ? */
2128                 if (x > rtpend)
2129                         /* then, start from the begingig. */
2130                         x = (rtpstart + 1) & ~1;
2131                 /* Check if we reached the place were we started. */
2132                 if (x == startplace) {
2133                         /* If so, there's no ports available. */
2134                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
2135                         close(rtp->s);
2136                         if (rtp->rtcp) {
2137                                 close(rtp->rtcp->s);
2138                                 ast_free(rtp->rtcp);
2139                         }
2140                         ast_free(rtp);
2141                         return NULL;
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
2154 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
2155 {
2156         struct in_addr ia;
2157
2158         memset(&ia, 0, sizeof(ia));
2159         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
2160 }
2161
2162 int ast_rtp_setqos(struct ast_rtp *rtp, int tos, int cos)
2163 {
2164         return ast_netsock_set_qos(rtp->s, tos, cos);
2165 }
2166
2167 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2168 {
2169         rtp->them.sin_port = them->sin_port;
2170         rtp->them.sin_addr = them->sin_addr;
2171         if (rtp->rtcp) {
2172                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
2173                 rtp->rtcp->them.sin_addr = them->sin_addr;
2174         }
2175         rtp->rxseqno = 0;
2176 }
2177
2178 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
2179 {
2180         if ((them->sin_family != AF_INET) ||
2181                 (them->sin_port != rtp->them.sin_port) ||
2182                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
2183                 them->sin_family = AF_INET;
2184                 them->sin_port = rtp->them.sin_port;
2185                 them->sin_addr = rtp->them.sin_addr;
2186                 return 1;
2187         }
2188         return 0;
2189 }
2190
2191 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
2192 {
2193         *us = rtp->us;
2194 }
2195
2196 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
2197 {
2198         struct ast_rtp *bridged = NULL;
2199
2200         rtp_bridge_lock(rtp);
2201         bridged = rtp->bridged;
2202         rtp_bridge_unlock(rtp);
2203
2204         return bridged;
2205 }
2206
2207 void ast_rtp_stop(struct ast_rtp *rtp)
2208 {
2209         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
2210                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2211                 rtp->rtcp->schedid = -1;
2212         }
2213
2214         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
2215         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
2216         if (rtp->rtcp) {
2217                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
2218                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
2219         }
2220         
2221         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
2222 }
2223
2224 void ast_rtp_reset(struct ast_rtp *rtp)
2225 {
2226         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
2227         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
2228         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
2229         rtp->lastts = 0;
2230         rtp->lastdigitts = 0;
2231         rtp->lastrxts = 0;
2232         rtp->lastividtimestamp = 0;
2233         rtp->lastovidtimestamp = 0;
2234         rtp->lastitexttimestamp = 0;
2235         rtp->lastotexttimestamp = 0;
2236         rtp->lasteventseqn = 0;
2237         rtp->lastevent = 0;
2238         rtp->lasttxformat = 0;
2239         rtp->lastrxformat = 0;
2240         rtp->dtmfcount = 0;
2241         rtp->dtmfsamples = 0;
2242         rtp->seqno = 0;
2243         rtp->rxseqno = 0;
2244 }
2245
2246 char *ast_rtp_get_quality(struct ast_rtp *rtp, struct ast_rtp_quality *qual)
2247 {
2248         /*
2249         *ssrc          our ssrc
2250         *themssrc      their ssrc
2251         *lp            lost packets
2252         *rxjitter      our calculated jitter(rx)
2253         *rxcount       no. received packets
2254         *txjitter      reported jitter of the other end
2255         *txcount       transmitted packets
2256         *rlp           remote lost packets
2257         *rtt           round trip time
2258         */
2259
2260         if (qual) {
2261                 qual->local_ssrc = rtp->ssrc;
2262                 qual->local_lostpackets = rtp->rtcp->expected_prior - rtp->rtcp->received_prior;
2263                 qual->local_jitter = rtp->rxjitter;
2264                 qual->local_count = rtp->rxcount;
2265                 qual->remote_ssrc = rtp->themssrc;
2266                 qual->remote_lostpackets = rtp->rtcp->reported_lost;
2267                 qual->remote_jitter = rtp->rtcp->reported_jitter / 65536.0;
2268                 qual->remote_count = rtp->txcount;
2269                 qual->rtt = rtp->rtcp->rtt;
2270         }
2271         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);
2272         
2273         return rtp->rtcp->quality;
2274 }
2275
2276 void ast_rtp_destroy(struct ast_rtp *rtp)
2277 {
2278         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
2279                 /*Print some info on the call here */
2280                 ast_verbose("  RTP-stats\n");
2281                 ast_verbose("* Our Receiver:\n");
2282                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
2283                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
2284                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
2285                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
2286                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2287                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2288                 ast_verbose("* Our Sender:\n");
2289                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2290                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2291                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2292                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2293                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2294                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2295         }
2296
2297         manager_event(EVENT_FLAG_REPORTING, "RTPReceiverStat", "SSRC: %u\r\n"
2298                                             "ReceivedPackets: %u\r\n"
2299                                             "LostPackets: %u\r\n"
2300                                             "Jitter: %.4f\r\n"
2301                                             "Transit: %.4f\r\n"
2302                                             "RRCount: %u\r\n",
2303                                             rtp->themssrc,
2304                                             rtp->rxcount,
2305                                             rtp->rtcp->expected_prior - rtp->rtcp->received_prior,
2306                                             rtp->rxjitter,
2307                                             rtp->rxtransit,
2308                                             rtp->rtcp->rr_count);
2309         manager_event(EVENT_FLAG_REPORTING, "RTPSenderStat", "SSRC: %u\r\n"
2310                                             "SentPackets: %u\r\n"
2311                                             "LostPackets: %u\r\n"
2312                                             "Jitter: %u\r\n"
2313                                             "SRCount: %u\r\n"
2314                                             "RTT: %f\r\n",
2315                                             rtp->ssrc,
2316                                             rtp->txcount,
2317                                             rtp->rtcp->reported_lost,
2318                                             rtp->rtcp->reported_jitter,
2319                                             rtp->rtcp->sr_count,
2320                                             rtp->rtcp->rtt);
2321         if (rtp->smoother)
2322                 ast_smoother_free(rtp->smoother);
2323         if (rtp->ioid)
2324                 ast_io_remove(rtp->io, rtp->ioid);
2325         if (rtp->s > -1)
2326                 close(rtp->s);
2327         if (rtp->rtcp) {
2328                 if (rtp->rtcp->schedid > 0)
2329                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2330                 close(rtp->rtcp->s);
2331                 ast_free(rtp->rtcp);
2332                 rtp->rtcp=NULL;
2333         }
2334 #ifdef P2P_INTENSE
2335         ast_mutex_destroy(&rtp->bridge_lock);
2336 #endif
2337         ast_free(rtp);
2338 }
2339
2340 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2341 {
2342         struct timeval t;
2343         long ms;
2344         if (ast_tvzero(rtp->txcore)) {
2345                 rtp->txcore = ast_tvnow();
2346                 /* Round to 20ms for nice, pretty timestamps */
2347                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2348         }
2349         /* Use previous txcore if available */
2350         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2351         ms = ast_tvdiff_ms(t, rtp->txcore);
2352         if (ms < 0)
2353                 ms = 0;
2354         /* Use what we just got for next time */
2355         rtp->txcore = t;
2356         return (unsigned int) ms;
2357 }
2358
2359 /*! \brief Send begin frames for DTMF */
2360 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2361 {
2362         unsigned int *rtpheader;
2363         int hdrlen = 12, res = 0, i = 0, payload = 0;
2364         char data[256];
2365
2366         if ((digit <= '9') && (digit >= '0'))
2367                 digit -= '0';
2368         else if (digit == '*')
2369                 digit = 10;
2370         else if (digit == '#')
2371                 digit = 11;
2372         else if ((digit >= 'A') && (digit <= 'D'))
2373                 digit = digit - 'A' + 12;
2374         else if ((digit >= 'a') && (digit <= 'd'))
2375                 digit = digit - 'a' + 12;
2376         else {
2377                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2378                 return 0;
2379         }
2380
2381         /* If we have no peer, return immediately */    
2382         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2383                 return 0;
2384
2385         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2386
2387         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2388         rtp->send_duration = 160;
2389         
2390         /* Get a pointer to the header */
2391         rtpheader = (unsigned int *)data;
2392         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2393         rtpheader[1] = htonl(rtp->lastdigitts);
2394         rtpheader[2] = htonl(rtp->ssrc); 
2395
2396         for (i = 0; i < 2; i++) {
2397                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2398                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2399                 if (res < 0) 
2400                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n",
2401                                 ast_inet_ntoa(rtp->them.sin_addr),
2402                                 ntohs(rtp->them.sin_port), strerror(errno));
2403                 if (rtp_debug_test_addr(&rtp->them))
2404                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2405                                     ast_inet_ntoa(rtp->them.sin_addr),
2406                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2407                 /* Increment sequence number */
2408                 rtp->seqno++;
2409                 /* Increment duration */
2410                 rtp->send_duration += 160;
2411                 /* Clear marker bit and set seqno */
2412                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2413         }
2414
2415         /* Since we received a begin, we can safely store the digit and disable any compensation */
2416         rtp->sending_digit = 1;
2417         rtp->send_digit = digit;
2418         rtp->send_payload = payload;
2419
2420         return 0;
2421 }
2422
2423 /*! \brief Send continuation frame for DTMF */
2424 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2425 {
2426         unsigned int *rtpheader;
2427         int hdrlen = 12, res = 0;
2428         char data[256];
2429
2430         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2431                 return 0;
2432
2433         /* Setup packet to send */
2434         rtpheader = (unsigned int *)data;
2435         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2436         rtpheader[1] = htonl(rtp->lastdigitts);
2437         rtpheader[2] = htonl(rtp->ssrc);
2438         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2439         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2440         
2441         /* Transmit */
2442         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2443         if (res < 0)
2444                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2445                         ast_inet_ntoa(rtp->them.sin_addr),
2446                         ntohs(rtp->them.sin_port), strerror(errno));
2447         if (rtp_debug_test_addr(&rtp->them))
2448                 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2449                             ast_inet_ntoa(rtp->them.sin_addr),
2450                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2451
2452         /* Increment sequence number */
2453         rtp->seqno++;
2454         /* Increment duration */
2455         rtp->send_duration += 160;
2456
2457         return 0;
2458 }
2459
2460 /*! \brief Send end packets for DTMF */
2461 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2462 {
2463         unsigned int *rtpheader;
2464         int hdrlen = 12, res = 0, i = 0;
2465         char data[256];
2466         
2467         /* If no address, then bail out */
2468         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2469                 return 0;
2470         
2471         if ((digit <= '9') && (digit >= '0'))
2472                 digit -= '0';
2473         else if (digit == '*')
2474                 digit = 10;
2475         else if (digit == '#')
2476                 digit = 11;
2477         else if ((digit >= 'A') && (digit <= 'D'))
2478                 digit = digit - 'A' + 12;
2479         else if ((digit >= 'a') && (digit <= 'd'))
2480                 digit = digit - 'a' + 12;
2481         else {
2482                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2483                 return 0;
2484         }
2485
2486         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2487
2488         rtpheader = (unsigned int *)data;
2489         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2490         rtpheader[1] = htonl(rtp->lastdigitts);
2491         rtpheader[2] = htonl(rtp->ssrc);
2492         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2493         /* Set end bit */
2494         rtpheader[3] |= htonl((1 << 23));
2495         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2496         /* Send 3 termination packets */
2497         for (i = 0; i < 3; i++) {
2498                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2499                 if (res < 0)
2500                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2501                                 ast_inet_ntoa(rtp->them.sin_addr),
2502                                 ntohs(rtp->them.sin_port), strerror(errno));
2503                 if (rtp_debug_test_addr(&rtp->them))
2504                         ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2505                                     ast_inet_ntoa(rtp->them.sin_addr),
2506                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2507         }
2508         rtp->sending_digit = 0;
2509         rtp->send_digit = 0;
2510         /* Increment lastdigitts */
2511         rtp->lastdigitts += 960;
2512         rtp->seqno++;
2513
2514         return res;
2515 }
2516
2517 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2518 int ast_rtcp_send_h261fur(void *data)
2519 {
2520         struct ast_rtp *rtp = data;
2521         int res;
2522
2523         rtp->rtcp->sendfur = 1;
2524         res = ast_rtcp_write(data);
2525         
2526         return res;
2527 }
2528
2529 /*! \brief Send RTCP sender's report */
2530 static int ast_rtcp_write_sr(void *data)
2531 {
2532         struct ast_rtp *rtp = data;
2533         int res;
2534         int len = 0;
2535         struct timeval now;
2536         unsigned int now_lsw;
2537         unsigned int now_msw;
2538         unsigned int *rtcpheader;
2539         unsigned int lost;
2540         unsigned int extended;
2541         unsigned int expected;
2542         unsigned int expected_interval;
2543         unsigned int received_interval;
2544         int lost_interval;
2545         int fraction;
2546         struct timeval dlsr;
2547         char bdata[512];
2548
2549         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2550         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2551                 return 0;
2552         
2553         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2554                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2555                 if (rtp->rtcp->schedid > 0)
2556                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2557                 rtp->rtcp->schedid = -1;
2558                 return 0;
2559         }
2560
2561         gettimeofday(&now, NULL);
2562         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2563         rtcpheader = (unsigned int *)bdata;
2564         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2565         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2566         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2567         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2568         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2569         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2570         len += 28;
2571         
2572         extended = rtp->cycles + rtp->lastrxseqno;
2573         expected = extended - rtp->seedrxseqno + 1;
2574         if (rtp->rxcount > expected) 
2575                 expected += rtp->rxcount - expected;
2576         lost = expected - rtp->rxcount;
2577         expected_interval = expected - rtp->rtcp->expected_prior;
2578         rtp->rtcp->expected_prior = expected;
2579         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2580         rtp->rtcp->received_prior = rtp->rxcount;
2581         lost_interval = expected_interval - received_interval;
2582         if (expected_interval == 0 || lost_interval <= 0)
2583                 fraction = 0;
2584         else
2585                 fraction = (lost_interval << 8) / expected_interval;
2586         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2587         rtcpheader[7] = htonl(rtp->themssrc);
2588         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2589         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2590         rtcpheader[10] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2591         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2592         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2593         len += 24;
2594         
2595         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2596
2597         if (rtp->rtcp->sendfur) {
2598                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2599                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2600                 len += 8;
2601                 rtp->rtcp->sendfur = 0;
2602         }
2603         
2604         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2605         /* it can change mid call, and SDES can't) */
2606         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2607         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2608         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2609         len += 12;
2610         
2611         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2612         if (res < 0) {
2613                 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));
2614                 if (rtp->rtcp->schedid > 0)
2615                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2616                 rtp->rtcp->schedid = -1;
2617                 return 0;
2618         }
2619         
2620         /* FIXME Don't need to get a new one */
2621         gettimeofday(&rtp->rtcp->txlsr, NULL);
2622         rtp->rtcp->sr_count++;
2623
2624         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2625         
2626         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2627                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2628                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2629                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2630                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2631                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2632                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2633                 ast_verbose("  Report block:\n");
2634                 ast_verbose("  Fraction lost: %u\n", fraction);
2635                 ast_verbose("  Cumulative loss: %u\n", lost);
2636                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2637                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2638                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2639         }
2640         manager_event(EVENT_FLAG_REPORTING, "RTCPSent", "To %s:%d\r\n"
2641                                             "OurSSRC: %u\r\n"
2642                                             "SentNTP: %u.%010u\r\n"
2643                                             "SentRTP: %u\r\n"
2644                                             "SentPackets: %u\r\n"
2645                                             "SentOctets: %u\r\n"
2646                                             "ReportBlock:\r\n"
2647                                             "FractionLost: %u\r\n"
2648                                             "CumulativeLoss: %u\r\n"
2649                                             "IAJitter: %.4f\r\n"
2650                                             "TheirLastSR: %u\r\n"
2651                                             "DLSR: %4.4f (sec)\r\n",
2652                                             ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port),
2653                                             rtp->ssrc,
2654                                             (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096,
2655                                             rtp->lastts,
2656                                             rtp->txcount,
2657                                             rtp->txoctetcount,
2658                                             fraction,
2659                                             lost,
2660                                             rtp->rxjitter,
2661                                             rtp->rtcp->themrxlsr,
2662                                             (double)(ntohl(rtcpheader[12])/65536.0));
2663         return res;
2664 }
2665
2666 /*! \brief Send RTCP recipient's report */
2667 static int ast_rtcp_write_rr(void *data)
2668 {
2669         struct ast_rtp *rtp = data;
2670         int res;
2671         int len = 32;
2672         unsigned int lost;
2673         unsigned int extended;
2674         unsigned int expected;
2675         unsigned int expected_interval;
2676         unsigned int received_interval;
2677         int lost_interval;
2678         struct timeval now;
2679         unsigned int *rtcpheader;
2680         char bdata[1024];
2681         struct timeval dlsr;
2682         int fraction;
2683
2684         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2685                 return 0;
2686           
2687         if (!rtp->rtcp->them.sin_addr.s_addr) {
2688                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted\n");
2689                 if (rtp->rtcp->schedid > 0)
2690                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2691                 rtp->rtcp->schedid = -1;
2692                 return 0;
2693         }
2694
2695         extended = rtp->cycles + rtp->lastrxseqno;
2696         expected = extended - rtp->seedrxseqno + 1;
2697         lost = expected - rtp->rxcount;
2698         expected_interval = expected - rtp->rtcp->expected_prior;
2699         rtp->rtcp->expected_prior = expected;
2700         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2701         rtp->rtcp->received_prior = rtp->rxcount;
2702         lost_interval = expected_interval - received_interval;
2703         if (expected_interval == 0 || lost_interval <= 0)
2704                 fraction = 0;
2705         else
2706                 fraction = (lost_interval << 8) / expected_interval;
2707         gettimeofday(&now, NULL);
2708         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2709         rtcpheader = (unsigned int *)bdata;
2710         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2711         rtcpheader[1] = htonl(rtp->ssrc);
2712         rtcpheader[2] = htonl(rtp->themssrc);
2713         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2714         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2715         rtcpheader[5] = htonl((unsigned int)(rtp->rxjitter * 65536.));
2716         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2717         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2718
2719         if (rtp->rtcp->sendfur) {
2720                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2721                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2722                 len += 8;
2723                 rtp->rtcp->sendfur = 0;
2724         }
2725
2726         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2727         it can change mid call, and SDES can't) */
2728         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2729         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2730         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2731         len += 12;
2732         
2733         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2734
2735         if (res < 0) {
2736                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2737                 /* Remove the scheduler */
2738                 if (rtp->rtcp->schedid > 0)
2739                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2740                 rtp->rtcp->schedid = -1;
2741                 return 0;
2742         }
2743
2744         rtp->rtcp->rr_count++;
2745
2746         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2747                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2748                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2749                         "  IA jitter: %.4f\n" 
2750                         "  Their last SR: %u\n" 
2751                         "  DLSR: %4.4f (sec)\n\n",
2752                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2753                         ntohs(rtp->rtcp->them.sin_port),
2754                         rtp->ssrc, rtp->themssrc, fraction, lost,
2755                         rtp->rxjitter,
2756                         rtp->rtcp->themrxlsr,
2757                         (double)(ntohl(rtcpheader[7])/65536.0));
2758         }
2759
2760         return res;
2761 }
2762
2763 /*! \brief Write and RTCP packet to the far end
2764  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2765  * RR is sent if we have not sent any rtp packets in the previous interval */
2766 static int ast_rtcp_write(void *data)
2767 {
2768         struct ast_rtp *rtp = data;
2769         int res;
2770         
2771         if (!rtp || !rtp->rtcp)
2772                 return 0;
2773
2774         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2775                 res = ast_rtcp_write_sr(data);
2776         else
2777                 res = ast_rtcp_write_rr(data);
2778         
2779         return res;
2780 }
2781
2782 /*! \brief generate comfort noice (CNG) */
2783 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2784 {
2785         unsigned int *rtpheader;
2786         int hdrlen = 12;
2787         int res;
2788         int payload;
2789         char data[256];
2790         level = 127 - (level & 0x7f);
2791         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2792
2793         /* If we have no peer, return immediately */    
2794         if (!rtp->them.sin_addr.s_addr)
2795                 return 0;
2796
2797         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2798
2799         /* Get a pointer to the header */
2800         rtpheader = (unsigned int *)data;
2801         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2802         rtpheader[1] = htonl(rtp->lastts);
2803         rtpheader[2] = htonl(rtp->ssrc); 
2804         data[12] = level;
2805         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2806                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2807                 if (res <0) 
2808                         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));
2809                 if (rtp_debug_test_addr(&rtp->them))
2810                         ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2811                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2812                    
2813         }
2814         return 0;
2815 }
2816
2817 /*! \brief Write RTP packet with audio or video media frames into UDP packet */
2818 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2819 {
2820         unsigned char *rtpheader;
2821         int hdrlen = 12;
2822         int res;
2823         unsigned int ms;
2824         int pred;
2825         int mark = 0;
2826
2827         ms = calc_txstamp(rtp, &f->delivery);
2828         /* Default prediction */
2829         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2830                 pred = rtp->lastts + f->samples;
2831
2832                 /* Re-calculate last TS */
2833                 rtp->lastts = rtp->lastts + ms * 8;
2834                 if (ast_tvzero(f->delivery)) {
2835                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2836                            and if so, go with our prediction */
2837                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2838                                 rtp->lastts = pred;
2839                         else {
2840                                 ast_debug(3, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2841                                 mark = 1;
2842                         }
2843                 }
2844         } else if(f->subclass < AST_FORMAT_MAX_VIDEO) {
2845                 mark = f->subclass & 0x1;
2846                 pred = rtp->lastovidtimestamp + f->samples;
2847                 /* Re-calculate last TS */
2848                 rtp->lastts = rtp->lastts + ms * 90;
2849                 /* If it's close to our prediction, go for it */
2850                 if (ast_tvzero(f->delivery)) {
2851                         if (abs(rtp->lastts - pred) < 7200) {
2852                                 rtp->lastts = pred;
2853                                 rtp->lastovidtimestamp += f->samples;
2854                         } else {
2855                                 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);
2856                                 rtp->lastovidtimestamp = rtp->lastts;
2857                         }
2858                 }
2859         } else {
2860                 pred = rtp->lastotexttimestamp + f->samples;
2861                 /* Re-calculate last TS */
2862                 rtp->lastts = rtp->lastts + ms * 90;
2863                 /* If it's close to our prediction, go for it */
2864                 if (ast_tvzero(f->delivery)) {
2865                         if (abs(rtp->lastts - pred) < 7200) {
2866                                 rtp->lastts = pred;
2867                                 rtp->lastotexttimestamp += f->samples;
2868                         } else {
2869                                 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);
2870                                 rtp->lastotexttimestamp = rtp->lastts;
2871                         }
2872                 }
2873         }
2874         /* If the timestamp for non-digit packets has moved beyond the timestamp
2875            for digits, update the digit timestamp.
2876         */
2877         if (rtp->lastts > rtp->lastdigitts)
2878                 rtp->lastdigitts = rtp->lastts;
2879
2880         if (f->has_timing_info)
2881                 rtp->lastts = f->ts * 8;
2882
2883         /* Get a pointer to the header */
2884         rtpheader = (unsigned char *)(f->data - hdrlen);
2885
2886         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2887         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2888         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2889
2890         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2891                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2892                 if (res <0) {
2893                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2894                                 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));
2895                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2896                                 /* Only give this error message once if we are not RTP debugging */
2897                                 if (option_debug || rtpdebug)
2898                                         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));
2899                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2900                         }
2901                 } else {
2902                         rtp->txcount++;
2903                         rtp->txoctetcount +=(res - hdrlen);
2904                         
2905                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2906                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2907                 }
2908                                 
2909                 if (rtp_debug_test_addr(&rtp->them))
2910                         ast_verbose("Sent RTP packet to      %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2911                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2912         }
2913
2914         rtp->seqno++;
2915
2916         return 0;
2917 }
2918
2919 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2920 {
2921         int x;
2922         for (x = 0; x < 32; x++) {  /* Ugly way */
2923                 rtp->pref.order[x] = prefs->order[x];
2924                 rtp->pref.framing[x] = prefs->framing[x];
2925         }
2926         if (rtp->smoother)
2927                 ast_smoother_free(rtp->smoother);
2928         rtp->smoother = NULL;
2929         return 0;
2930 }
2931
2932 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2933 {
2934         return &rtp->pref;
2935 }
2936
2937 int ast_rtp_codec_getformat(int pt)
2938 {
2939         if (pt < 0 || pt > MAX_RTP_PT)
2940                 return 0; /* bogus payload type */
2941
2942         if (static_RTP_PT[pt].isAstFormat)
2943                 return static_RTP_PT[pt].code;
2944         else
2945                 return 0;
2946 }
2947
2948 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2949 {
2950         struct ast_frame *f;
2951         int codec;
2952         int hdrlen = 12;
2953         int subclass;
2954         
2955
2956         /* If we have no peer, return immediately */    
2957         if (!rtp->them.sin_addr.s_addr)
2958                 return 0;
2959
2960         /* If there is no data length, return immediately */
2961         if (!_f->datalen) 
2962                 return 0;
2963         
2964         /* Make sure we have enough space for RTP header */
2965         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO) && (_f->frametype != AST_FRAME_TEXT)) {
2966                 ast_log(LOG_WARNING, "RTP can only send voice, video and text\n");
2967                 return -1;
2968         }
2969
2970         /* The bottom bit of a video subclass contains the marker bit */
2971         subclass = _f->subclass;
2972         if (_f->frametype == AST_FRAME_VIDEO)
2973                 subclass &= ~0x1;
2974
2975         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2976         if (codec < 0) {
2977                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2978                 return -1;
2979         }
2980
2981         if (rtp->lasttxformat != subclass) {
2982                 /* New format, reset the smoother */
2983                 ast_debug(1, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2984                 rtp->lasttxformat = subclass;
2985                 if (rtp->smoother)
2986                         ast_smoother_free(rtp->smoother);
2987                 rtp->smoother = NULL;
2988         }
2989
2990         if (!rtp->smoother && subclass != AST_FORMAT_SPEEX) {
2991                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2992                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2993                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2994                                 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));
2995                                 return -1;
2996                         }
2997                         if (fmt.flags)
2998                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2999                         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));
3000                 }
3001         }
3002         if (rtp->smoother) {
3003                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
3004                         ast_smoother_feed_be(rtp->smoother, _f);
3005                 } else {
3006                         ast_smoother_feed(rtp->smoother, _f);
3007                 }
3008
3009                 while ((f = ast_smoother_read(rtp->smoother)) && (f->data))
3010                         ast_rtp_raw_write(rtp, f, codec);
3011         } else {
3012                 /* Don't buffer outgoing frames; send them one-per-packet: */
3013                 if (_f->offset < hdrlen) 
3014                         f = ast_frdup(_f);      /*! \bug XXX this might never be free'd. Why do we do this? */
3015                 else
3016                         f = _f;
3017                 if (f->data)
3018                         ast_rtp_raw_write(rtp, f, codec);
3019                 if (f != _f)
3020                         ast_frfree(f);
3021         }
3022                 
3023         return 0;
3024 }
3025
3026 /*! \brief Unregister interface to channel driver */
3027 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
3028 {
3029         AST_RWLIST_WRLOCK(&protos);
3030         AST_RWLIST_REMOVE(&protos, proto, list);
3031         AST_RWLIST_UNLOCK(&protos);
3032 }
3033
3034 /*! \brief Register interface to channel driver */
3035 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
3036 {
3037         struct ast_rtp_protocol *cur;
3038
3039         AST_RWLIST_WRLOCK(&protos);
3040         AST_RWLIST_TRAVERSE(&protos, cur, list) {       
3041                 if (!strcmp(cur->type, proto->type)) {
3042                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
3043                         AST_RWLIST_UNLOCK(&protos);
3044                         return -1;
3045                 }
3046         }
3047         AST_RWLIST_INSERT_HEAD(&protos, proto, list);
3048         AST_RWLIST_UNLOCK(&protos);
3049         
3050         return 0;
3051 }
3052
3053 /*! \brief Bridge loop for true native bridge (reinvite) */
3054 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)
3055 {
3056         struct ast_frame *fr = NULL;
3057         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
3058         int oldcodec0 = codec0, oldcodec1 = codec1;
3059         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, tac1 = {0,}, ac0 = {0,}, vac0 = {0,}, tac0 = {0,};
3060         struct sockaddr_in t1 = {0,}, vt1 = {0,}, tt1 = {0,}, t0 = {0,}, vt0 = {0,}, tt0 = {0,};
3061         
3062         /* Set it up so audio goes directly between the two endpoints */
3063
3064         /* Test the first channel */
3065         if (!(pr0->set_rtp_peer(c0, p1, vp1, tp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
3066                 ast_rtp_get_peer(p1, &ac1);
3067                 if (vp1)
3068                         ast_rtp_get_peer(vp1, &vac1);
3069                 if (tp1)
3070                         ast_rtp_get_peer(tp1, &tac1);
3071         } else
3072                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
3073         
3074         /* Test the second channel */
3075         if (!(pr1->set_rtp_peer(c1, p0, vp0, tp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
3076                 ast_rtp_get_peer(p0, &ac0);
3077                 if (vp0)
3078                         ast_rtp_get_peer(vp0, &vac0);
3079                 if (tp0)
3080                         ast_rtp_get_peer(tp0, &tac0);
3081         } else
3082                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
3083
3084         /* Now we can unlock and move into our loop */
3085         ast_channel_unlock(c0);
3086         ast_channel_unlock(c1);
3087
3088         /* Throw our channels into the structure and enter the loop */
3089         cs[0] = c0;
3090         cs[1] = c1;
3091         cs[2] = NULL;
3092         for (;;) {
3093                 /* Check if anything changed */
3094                 if ((c0->tech_pvt != pvt0) ||
3095                     (c1->tech_pvt != pvt1) ||
3096                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
3097                         ast_debug(1, "Oooh, something is weird, backing out\n");
3098                         if (c0->tech_pvt == pvt0)
3099                                 if (pr0->set_rtp_peer(c0, NULL, NULL, NULL, 0, 0))
3100                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
3101                         if (c1->tech_pvt == pvt1)
3102                                 if (pr1->set_rtp_peer(c1, NULL, NULL, NULL, 0, 0))
3103                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
3104                         return AST_BRIDGE_RETRY;
3105                 }
3106
3107                 /* Check if they have changed their address */
3108                 ast_rtp_get_peer(p1, &t1);
3109                 if (vp1)
3110                         ast_rtp_get_peer(vp1, &vt1);
3111                 if (tp1)
3112                         ast_rtp_get_peer(tp1, &tt1);
3113                 if (pr1->get_codec)
3114                         codec1 = pr1->get_codec(c1);
3115                 ast_rtp_get_peer(p0, &t0);
3116                 if (vp0)
3117                         ast_rtp_get_peer(vp0, &vt0);
3118                 if (tp0)
3119                         ast_rtp_get_peer(tp0, &tt0);
3120                 if (pr0->get_codec)
3121                         codec0 = pr0->get_codec(c0);
3122                 if ((inaddrcmp(&t1, &ac1)) ||
3123                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
3124                     (tp1 && inaddrcmp(&tt1, &tac1)) ||
3125                     (codec1 != oldcodec1)) {
3126                         ast_debug(2, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
3127                                 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
3128                         ast_debug(2, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
3129                                 c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
3130                         ast_debug(2, "Oooh, '%s' changed end taddress to %s:%d (format %d)\n",
3131                                 c1->name, ast_inet_ntoa(tt1.sin_addr), ntohs(tt1.sin_port), codec1);
3132                         ast_debug(2, "Oooh, '%s' was %s:%d/(format %d)\n",