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