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