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