4570c2fcc997a3f7cf8d56b9073f01f6e4045fd9
[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         unsigned char seq;
608         unsigned int flags;
609         unsigned int power;
610
611         /* We should have at least 4 bytes in RTP data */
612         if (len < 4)
613                 return f;
614
615         /*      The format of Cisco RTP DTMF packet looks like next:
616                 +0                              - sequence number of DTMF RTP packet (begins from 1,
617                                                   wrapped to 0)
618                 +1                              - set of flags
619                 +1 (bit 0)              - flaps by different DTMF digits delimited by audio
620                                                   or repeated digit without audio???
621                 +2 (+4,+6,...)  - power level? (rises from 0 to 32 at begin of tone
622                                                   then falls to 0 at its end)
623                 +3 (+5,+7,...)  - detected DTMF digit (0..9,*,#,A-D,...)
624                 Repeated DTMF information (bytes 4/5, 6/7) is history shifted right
625                 by each new packet and thus provides some redudancy.
626                 
627                 Sample of Cisco RTP DTMF packet is (all data in hex):
628                         19 07 00 02 12 02 20 02
629                 showing end of DTMF digit '2'.
630
631                 The packets
632                         27 07 00 02 0A 02 20 02
633                         28 06 20 02 00 02 0A 02
634                 shows begin of new digit '2' with very short pause (20 ms) after
635                 previous digit '2'. Bit +1.0 flips at begin of new digit.
636                 
637                 Cisco RTP DTMF packets comes as replacement of audio RTP packets
638                 so its uses the same sequencing and timestamping rules as replaced
639                 audio packets. Repeat interval of DTMF packets is 20 ms and not rely
640                 on audio framing parameters. Marker bit isn't used within stream of
641                 DTMFs nor audio stream coming immediately after DTMF stream. Timestamps
642                 are not sequential at borders between DTMF and audio streams,
643         */
644
645         seq = data[0];
646         flags = data[1];
647         power = data[2];
648         event = data[3] & 0x1f;
649
650         if (option_debug > 2 || rtpdebug)
651                 ast_log(LOG_DEBUG, "Cisco DTMF Digit: %02x (len=%d, seq=%d, flags=%02x, power=%d, history count=%d)\n", event, len, seq, flags, power, (len - 4) / 2);
652         if (event < 10) {
653                 resp = '0' + event;
654         } else if (event < 11) {
655                 resp = '*';
656         } else if (event < 12) {
657                 resp = '#';
658         } else if (event < 16) {
659                 resp = 'A' + (event - 12);
660         } else if (event < 17) {
661                 resp = 'X';
662         }
663         if ((!rtp->resp && power) || (rtp->resp && (rtp->resp != resp))) {
664                 rtp->resp = resp;
665                 /* Why we should care on DTMF compensation at reception? */
666                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE)) {
667                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
668                         rtp->dtmfduration = 0;
669                 }
670         } else if ((rtp->resp == resp) && !power) {
671                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
672                 f->samples = rtp->dtmfduration * 8;
673                 rtp->resp = 0;
674         } else if (rtp->resp == resp)
675                 rtp->dtmfduration += 20 * 8;
676         rtp->dtmfcount = dtmftimeout;
677         return f;
678 }
679
680 /*! 
681  * \brief Process RTP DTMF and events according to RFC 2833.
682  * 
683  * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
684  * 
685  * \param rtp
686  * \param data
687  * \param len
688  * \param seqno
689  * \returns
690  */
691 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
692 {
693         unsigned int event;
694         unsigned int event_end;
695         unsigned int duration;
696         char resp = 0;
697         struct ast_frame *f = NULL;
698
699         /* Figure out event, event end, and duration */
700         event = ntohl(*((unsigned int *)(data)));
701         event >>= 24;
702         event_end = ntohl(*((unsigned int *)(data)));
703         event_end <<= 8;
704         event_end >>= 24;
705         duration = ntohl(*((unsigned int *)(data)));
706         duration &= 0xFFFF;
707
708         /* Print out debug if turned on */
709         if (rtpdebug || option_debug > 2)
710                 ast_log(LOG_DEBUG, "- RTP 2833 Event: %08x (len = %d)\n", event, len);
711
712         /* Figure out what digit was pressed */
713         if (event < 10) {
714                 resp = '0' + event;
715         } else if (event < 11) {
716                 resp = '*';
717         } else if (event < 12) {
718                 resp = '#';
719         } else if (event < 16) {
720                 resp = 'A' + (event - 12);
721         } else if (event < 17) {        /* Event 16: Hook flash */
722                 resp = 'X';     
723         }
724
725         if ((!(rtp->resp) && (!(event_end & 0x80))) || (rtp->resp && rtp->resp != resp)) {
726                 rtp->resp = resp;
727                 if (!ast_test_flag(rtp, FLAG_DTMF_COMPENSATE))
728                         f = send_dtmf(rtp, AST_FRAME_DTMF_BEGIN);
729         } else if (event_end & 0x80 && rtp->lasteventendseqn != seqno && rtp->resp) {
730                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
731                 f->samples = duration;
732                 rtp->resp = 0;
733                 rtp->lasteventendseqn = seqno;
734         } else if (ast_test_flag(rtp, FLAG_DTMF_COMPENSATE) && event_end & 0x80 && rtp->lasteventendseqn != seqno) {
735                 rtp->resp = resp;
736                 f = send_dtmf(rtp, AST_FRAME_DTMF_END);
737                 f->samples = duration;
738                 rtp->resp = 0;
739                 rtp->lasteventendseqn = seqno;
740         }
741
742         rtp->dtmfcount = dtmftimeout;
743         rtp->dtmfduration = duration;
744
745         return f;
746 }
747
748 /*!
749  * \brief Process Comfort Noise RTP.
750  * 
751  * This is incomplete at the moment.
752  * 
753 */
754 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
755 {
756         struct ast_frame *f = NULL;
757         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
758            totally help us out becuase we don't have an engine to keep it going and we are not
759            guaranteed to have it every 20ms or anything */
760         if (rtpdebug)
761                 ast_log(LOG_DEBUG, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp->lastrxformat, len);
762
763         if (!(ast_test_flag(rtp, FLAG_3389_WARNING))) {
764                 ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
765                         ast_inet_ntoa(rtp->them.sin_addr));
766                 ast_set_flag(rtp, FLAG_3389_WARNING);
767         }
768
769         /* Must have at least one byte */
770         if (!len)
771                 return NULL;
772         if (len < 24) {
773                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
774                 rtp->f.datalen = len - 1;
775                 rtp->f.offset = AST_FRIENDLY_OFFSET;
776                 memcpy(rtp->f.data, data + 1, len - 1);
777         } else {
778                 rtp->f.data = NULL;
779                 rtp->f.offset = 0;
780                 rtp->f.datalen = 0;
781         }
782         rtp->f.frametype = AST_FRAME_CNG;
783         rtp->f.subclass = data[0] & 0x7f;
784         rtp->f.datalen = len - 1;
785         rtp->f.samples = 0;
786         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
787         f = &rtp->f;
788         return f;
789 }
790
791 static int rtpread(int *id, int fd, short events, void *cbdata)
792 {
793         struct ast_rtp *rtp = cbdata;
794         struct ast_frame *f;
795         f = ast_rtp_read(rtp);
796         if (f) {
797                 if (rtp->callback)
798                         rtp->callback(rtp, f, rtp->data);
799         }
800         return 1;
801 }
802
803 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
804 {
805         socklen_t len;
806         int position, i, packetwords;
807         int res;
808         struct sockaddr_in sin;
809         unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET];
810         unsigned int *rtcpheader;
811         int pt;
812         struct timeval now;
813         unsigned int length;
814         int rc;
815         double rtt = 0;
816         double a;
817         double dlsr;
818         double lsr;
819         unsigned int msw;
820         unsigned int lsw;
821         unsigned int comp;
822         struct ast_frame *f = &ast_null_frame;
823         
824         if (!rtp || !rtp->rtcp)
825                 return &ast_null_frame;
826
827         len = sizeof(sin);
828         
829         res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET,
830                                         0, (struct sockaddr *)&sin, &len);
831         rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET);
832         
833         if (res < 0) {
834                 if (errno != EAGAIN)
835                         ast_log(LOG_WARNING, "RTCP Read error: %s\n", strerror(errno));
836                 if (errno == EBADF)
837                         CRASH;
838                 return &ast_null_frame;
839         }
840
841         packetwords = res / 4;
842         
843         if (rtp->nat) {
844                 /* Send to whoever sent to us */
845                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
846                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
847                         memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
848                         if (option_debug || rtpdebug)
849                                 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));
850                 }
851         }
852
853         /* If we are P2P bridged to another RTP stream, send it directly over */
854         if (ast_rtp_get_bridged(rtp) && !bridge_p2p_rtcp_write(rtp, rtcpheader, res))
855                 return &ast_null_frame;
856
857         if (option_debug)
858                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
859
860         /* Process a compound packet */
861         position = 0;
862         while (position < packetwords) {
863                 i = position;
864                 length = ntohl(rtcpheader[i]);
865                 pt = (length & 0xff0000) >> 16;
866                 rc = (length & 0x1f000000) >> 24;
867                 length &= 0xffff;
868     
869                 if ((i + length) > packetwords) {
870                         ast_log(LOG_WARNING, "RTCP Read too short\n");
871                         return &ast_null_frame;
872                 }
873                 
874                 if (rtcp_debug_test_addr(&sin)) {
875                         ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
876                         ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown");
877                         ast_verbose("Reception reports: %d\n", rc);
878                         ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]);
879                 }
880     
881                 i += 2; /* Advance past header and ssrc */
882                 
883                 switch (pt) {
884                 case RTCP_PT_SR:
885                         gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */
886                         rtp->rtcp->spc = ntohl(rtcpheader[i+3]);
887                         rtp->rtcp->soc = ntohl(rtcpheader[i + 4]);
888                         rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff) >> 16); /* Going to LSR in RR*/
889     
890                         if (rtcp_debug_test_addr(&sin)) {
891                                 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096);
892                                 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2]));
893                                 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4]));
894                         }
895                         i += 5;
896                         if (rc < 1)
897                                 break;
898                         /* Intentional fall through */
899                 case RTCP_PT_RR:
900                         /* This is the place to calculate RTT */
901                         /* Don't handle multiple reception reports (rc > 1) yet */
902                         gettimeofday(&now, NULL);
903                         timeval2ntp(now, &msw, &lsw);
904                         /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */
905                         if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */
906                                 comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16);
907                                 a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.);
908                                 lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.);
909                                 dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.);
910                                 rtt = a - dlsr - lsr;
911                                 rtp->rtcp->accumulated_transit += rtt;
912                                 rtp->rtcp->rtt = rtt;
913                                 if (rtp->rtcp->maxrtt<rtt)
914                                         rtp->rtcp->maxrtt = rtt;
915                                 if (rtp->rtcp->minrtt>rtt)
916                                 rtp->rtcp->minrtt = rtt;
917                         }
918                         rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]);
919                         rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff;
920                         if (rtcp_debug_test_addr(&sin)) {
921                                 ast_verbose("Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24));
922                                 ast_verbose("Packets lost so far: %d\n", rtp->rtcp->reported_lost);
923                                 ast_verbose("Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff));
924                                 ast_verbose("Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16);
925                                 ast_verbose("Interarrival jitter: %u\n", rtp->rtcp->reported_jitter);
926                                 ast_verbose("Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096);
927                                 ast_verbose("DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0);
928                                 if (rtt)
929                                         ast_verbose("RTT: %f(sec)\n", rtt);
930                         }
931                         break;
932                 case RTCP_PT_FUR:
933                         if (rtcp_debug_test_addr(&sin))
934                                 ast_verbose("Received an RTCP Fast Update Request\n");
935                         rtp->f.frametype = AST_FRAME_CONTROL;
936                         rtp->f.subclass = AST_CONTROL_VIDUPDATE;
937                         rtp->f.datalen = 0;
938                         rtp->f.samples = 0;
939                         rtp->f.mallocd = 0;
940                         rtp->f.src = "RTP";
941                         f = &rtp->f;
942                         break;
943                 case RTCP_PT_SDES:
944                         if (rtcp_debug_test_addr(&sin))
945                                 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
946                         break;
947                 case RTCP_PT_BYE:
948                         if (rtcp_debug_test_addr(&sin))
949                                 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
950                         break;
951                 default:
952                         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));
953                         break;
954                 }
955                 position += (length + 1);
956         }
957                         
958         return f;
959 }
960
961 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
962 {
963         struct timeval now;
964         double transit;
965         double current_time;
966         double d;
967         double dtv;
968         double prog;
969         
970         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
971                 gettimeofday(&rtp->rxcore, NULL);
972                 rtp->drxcore = (double) rtp->rxcore.tv_sec + (double) rtp->rxcore.tv_usec / 1000000;
973                 /* map timestamp to a real time */
974                 rtp->seedrxts = timestamp; /* Their RTP timestamp started with this */
975                 rtp->rxcore.tv_sec -= timestamp / 8000;
976                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
977                 /* Round to 0.1ms for nice, pretty timestamps */
978                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 100;
979                 if (rtp->rxcore.tv_usec < 0) {
980                         /* Adjust appropriately if necessary */
981                         rtp->rxcore.tv_usec += 1000000;
982                         rtp->rxcore.tv_sec -= 1;
983                 }
984         }
985
986         gettimeofday(&now,NULL);
987         /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
988         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
989         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
990         if (tv->tv_usec >= 1000000) {
991                 tv->tv_usec -= 1000000;
992                 tv->tv_sec += 1;
993         }
994         prog = (double)((timestamp-rtp->seedrxts)/8000.);
995         dtv = (double)rtp->drxcore + (double)(prog);
996         current_time = (double)now.tv_sec + (double)now.tv_usec/1000000;
997         transit = current_time - dtv;
998         d = transit - rtp->rxtransit;
999         rtp->rxtransit = transit;
1000         if (d<0)
1001                 d=-d;
1002         rtp->rxjitter += (1./16.) * (d - rtp->rxjitter);
1003         if (rtp->rtcp && rtp->rxjitter > rtp->rtcp->maxrxjitter)
1004                 rtp->rtcp->maxrxjitter = rtp->rxjitter;
1005         if (rtp->rtcp && rtp->rxjitter < rtp->rtcp->minrxjitter)
1006                 rtp->rtcp->minrxjitter = rtp->rxjitter;
1007 }
1008
1009 /*! \brief Perform a Packet2Packet RTCP write */
1010 static int bridge_p2p_rtcp_write(struct ast_rtp *rtp, unsigned int *rtcpheader, int len)
1011 {
1012         struct ast_rtp *bridged = ast_rtp_get_bridged(rtp);
1013         int res = 0;
1014
1015         /* If RTCP is not present on the bridged RTP session, then ignore this */
1016         if (!bridged->rtcp)
1017                 return 0;
1018
1019         /* Send the data out */
1020         res = sendto(bridged->rtcp->s, (void *)rtcpheader, len, 0, (struct sockaddr *)&bridged->rtcp->them, sizeof(bridged->rtcp->them));
1021         if (res < 0) {
1022                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1023                         if (option_debug)
1024                                 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));
1025                 }
1026                 else if ((((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug)) && (option_debug || rtpdebug)) {
1027                         if (option_debug)
1028                                 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));
1029                 }
1030         } else if (rtp_debug_test_addr(&bridged->rtcp->them)) {
1031                 if (option_verbose)
1032                         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);
1033                 }
1034
1035         return 0;
1036 }
1037
1038 /*! \brief Perform a Packet2Packet RTP write */
1039 static int bridge_p2p_rtp_write(struct ast_rtp *rtp, unsigned int *rtpheader, int len, int hdrlen)
1040 {
1041         struct ast_rtp *bridged = ast_rtp_get_bridged(rtp);
1042         int res = 0, payload = 0, bridged_payload = 0, version, padding, mark, ext;
1043         struct rtpPayloadType rtpPT;
1044         unsigned int seqno;
1045         
1046         /* Get fields from packet */
1047         seqno = ntohl(rtpheader[0]);
1048         version = (seqno & 0xC0000000) >> 30;
1049         payload = (seqno & 0x7f0000) >> 16;
1050         padding = seqno & (1 << 29);
1051         mark = seqno & (1 << 23);
1052         ext = seqno & (1 << 28);
1053         seqno &= 0xffff;
1054
1055         /* Check what the payload value should be */
1056         rtpPT = ast_rtp_lookup_pt(rtp, payload);
1057
1058         /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1059         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) && !rtpPT.isAstFormat && rtpPT.code == AST_RTP_DTMF)
1060                 return -1;
1061
1062         /* Otherwise adjust bridged payload to match */
1063         bridged_payload = ast_rtp_lookup_code(bridged, rtpPT.isAstFormat, rtpPT.code);
1064
1065         /* If the mark bit has not been sent yet... do it now */
1066         if (!ast_test_flag(rtp, FLAG_P2P_SENT_MARK)) {
1067                 mark = 1;
1068                 ast_set_flag(rtp, FLAG_P2P_SENT_MARK);
1069         }
1070
1071         /* Reconstruct part of the packet */
1072         rtpheader[0] = htonl((version << 30) | (mark << 23) | (bridged_payload << 16) | (seqno));
1073
1074         /* Send the packet back out */
1075         res = sendto(bridged->s, (void *)rtpheader, len, 0, (struct sockaddr *)&bridged->them, sizeof(bridged->them));
1076         if (res < 0) {
1077                 if (!bridged->nat || (bridged->nat && (ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
1078                         if (option_debug)
1079                                 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));
1080                 } else if (((ast_test_flag(bridged, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(bridged, FLAG_NAT_INACTIVE_NOWARN)) {
1081                         if (option_debug || rtpdebug)
1082                                 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));
1083                         ast_set_flag(bridged, FLAG_NAT_INACTIVE_NOWARN);
1084                 }
1085                 return -1;
1086         } else if (rtp_debug_test_addr(&bridged->them))
1087                         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);
1088
1089         return -1;
1090 }
1091
1092 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
1093 {
1094         int res;
1095         struct sockaddr_in sin;
1096         socklen_t len;
1097         unsigned int seqno;
1098         int version;
1099         int payloadtype;
1100         int tseqno;
1101         int hdrlen = 12;
1102         int padding;
1103         int mark;
1104         int ext;
1105         unsigned int ssrc;
1106         unsigned int timestamp;
1107         unsigned int *rtpheader;
1108         struct rtpPayloadType rtpPT;
1109         
1110         /* If time is up, kill it */
1111         if (rtp->send_digit)
1112                 ast_rtp_senddigit_continuation(rtp);
1113
1114         len = sizeof(sin);
1115         
1116         /* Cache where the header will go */
1117         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
1118                                         0, (struct sockaddr *)&sin, &len);
1119
1120         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
1121         if (res < 0) {
1122                 if (errno != EAGAIN)
1123                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
1124                 if (errno == EBADF)
1125                         CRASH;
1126                 return &ast_null_frame;
1127         }
1128         
1129         if (res < hdrlen) {
1130                 ast_log(LOG_WARNING, "RTP Read too short\n");
1131                 return &ast_null_frame;
1132         }
1133
1134         /* Get fields */
1135         seqno = ntohl(rtpheader[0]);
1136
1137         /* Check RTP version */
1138         version = (seqno & 0xC0000000) >> 30;
1139         if (!version) {
1140                 if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) &&
1141                         (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) {
1142                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
1143                 }
1144                 return &ast_null_frame;
1145         }
1146
1147 #if 0   /* Allow to receive RTP stream with closed transmission path */
1148         /* If we don't have the other side's address, then ignore this */
1149         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
1150                 return &ast_null_frame;
1151 #endif
1152
1153         /* Send to whoever send to us if NAT is turned on */
1154         if (rtp->nat) {
1155                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
1156                     (rtp->them.sin_port != sin.sin_port)) {
1157                         rtp->them = sin;
1158                         if (rtp->rtcp) {
1159                                 memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them));
1160                                 rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1);
1161                         }
1162                         rtp->rxseqno = 0;
1163                         ast_set_flag(rtp, FLAG_NAT_ACTIVE);
1164                         if (option_debug || rtpdebug)
1165                                 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));
1166                 }
1167         }
1168
1169         /* If we are bridged to another RTP stream, send direct */
1170         if (ast_rtp_get_bridged(rtp) && !bridge_p2p_rtp_write(rtp, rtpheader, res, hdrlen))
1171                 return &ast_null_frame;
1172
1173         if (version != 2)
1174                 return &ast_null_frame;
1175
1176         payloadtype = (seqno & 0x7f0000) >> 16;
1177         padding = seqno & (1 << 29);
1178         mark = seqno & (1 << 23);
1179         ext = seqno & (1 << 28);
1180         seqno &= 0xffff;
1181         timestamp = ntohl(rtpheader[1]);
1182         ssrc = ntohl(rtpheader[2]);
1183         
1184         if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) {
1185                 if (option_debug || rtpdebug)
1186                         ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n");
1187                 mark = 1;
1188         }
1189
1190         rtp->rxssrc = ssrc;
1191         
1192         if (padding) {
1193                 /* Remove padding bytes */
1194                 res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1];
1195         }
1196         
1197         if (ext) {
1198                 /* RTP Extension present */
1199                 hdrlen += 4;
1200                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
1201                 if (option_debug) {
1202                         int profile;
1203                         profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16;
1204                         if (profile == 0x505a)
1205                                 ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n");
1206                         else
1207                                 ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile);
1208                 }
1209         }
1210
1211         if (res < hdrlen) {
1212                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
1213                 return &ast_null_frame;
1214         }
1215
1216         rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1217
1218         tseqno = rtp->lastrxseqno +1;
1219
1220         if (rtp->rxcount==1) {
1221                 /* This is the first RTP packet successfully received from source */
1222                 rtp->seedrxseqno = seqno;
1223         }
1224
1225         /* Do not schedule RR if RTCP isn't run */
1226         if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) {
1227                 /* Schedule transmission of Receiver Report */
1228                 rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
1229         }
1230
1231         if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */
1232                 rtp->cycles += RTP_SEQ_MOD;
1233                 ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno);
1234         }
1235
1236         rtp->lastrxseqno = seqno;
1237         
1238         if (rtp->themssrc==0)
1239                 rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */
1240         
1241         if (rtp_debug_test_addr(&sin))
1242                 ast_verbose("Got  RTP packet from    %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1243                         ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
1244
1245         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
1246         if (!rtpPT.isAstFormat) {
1247                 struct ast_frame *f = NULL;
1248
1249                 /* This is special in-band data that's not one of our codecs */
1250                 if (rtpPT.code == AST_RTP_DTMF) {
1251                         /* It's special -- rfc2833 process it */
1252                         if (rtp_debug_test_addr(&sin)) {
1253                                 unsigned char *data;
1254                                 unsigned int event;
1255                                 unsigned int event_end;
1256                                 unsigned int duration;
1257                                 data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen;
1258                                 event = ntohl(*((unsigned int *)(data)));
1259                                 event >>= 24;
1260                                 event_end = ntohl(*((unsigned int *)(data)));
1261                                 event_end <<= 8;
1262                                 event_end >>= 24;
1263                                 duration = ntohl(*((unsigned int *)(data)));
1264                                 duration &= 0xFFFF;
1265                                 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);
1266                         }
1267                         f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno);
1268                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
1269                         /* It's really special -- process it the Cisco way */
1270                         if (rtp->lasteventseqn <= seqno || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
1271                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1272                                 rtp->lasteventseqn = seqno;
1273                         }
1274                 } else if (rtpPT.code == AST_RTP_CN) {
1275                         /* Comfort Noise */
1276                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
1277                 } else {
1278                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr));
1279                 }
1280                 return f ? f : &ast_null_frame;
1281         }
1282         rtp->lastrxformat = rtp->f.subclass = rtpPT.code;
1283         rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO;
1284
1285         if (!rtp->lastrxts)
1286                 rtp->lastrxts = timestamp;
1287
1288         rtp->rxseqno = seqno;
1289
1290         /* Record received timestamp as last received now */
1291         rtp->lastrxts = timestamp;
1292
1293         rtp->f.mallocd = 0;
1294         rtp->f.datalen = res - hdrlen;
1295         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
1296         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
1297         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
1298                 rtp->f.samples = ast_codec_get_samples(&rtp->f);
1299                 if (rtp->f.subclass == AST_FORMAT_SLINEAR) 
1300                         ast_frame_byteswap_be(&rtp->f);
1301                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
1302                 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1303                 rtp->f.has_timing_info = 1;
1304                 rtp->f.ts = timestamp / 8;
1305                 rtp->f.len = rtp->f.samples / 8;
1306                 rtp->f.seqno = seqno;
1307         } else {
1308                 /* Video -- samples is # of samples vs. 90000 */
1309                 if (!rtp->lastividtimestamp)
1310                         rtp->lastividtimestamp = timestamp;
1311                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
1312                 rtp->lastividtimestamp = timestamp;
1313                 rtp->f.delivery.tv_sec = 0;
1314                 rtp->f.delivery.tv_usec = 0;
1315                 if (mark)
1316                         rtp->f.subclass |= 0x1;
1317                 
1318         }
1319         rtp->f.src = "RTP";
1320         return &rtp->f;
1321 }
1322
1323 /* The following array defines the MIME Media type (and subtype) for each
1324    of our codecs, or RTP-specific data type. */
1325 static struct {
1326         struct rtpPayloadType payloadType;
1327         char* type;
1328         char* subtype;
1329 } mimeTypes[] = {
1330         {{1, AST_FORMAT_G723_1}, "audio", "G723"},
1331         {{1, AST_FORMAT_GSM}, "audio", "GSM"},
1332         {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
1333         {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
1334         {{1, AST_FORMAT_G726}, "audio", "G726-32"},
1335         {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
1336         {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
1337         {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
1338         {{1, AST_FORMAT_G729A}, "audio", "G729"},
1339         {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
1340         {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
1341         {{1, AST_FORMAT_G722}, "audio", "G722"},
1342         {{1, AST_FORMAT_G726_AAL2}, "audio", "AAL2-G726-32"},
1343         {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
1344         {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
1345         {{0, AST_RTP_CN}, "audio", "CN"},
1346         {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
1347         {{1, AST_FORMAT_PNG}, "video", "PNG"},
1348         {{1, AST_FORMAT_H261}, "video", "H261"},
1349         {{1, AST_FORMAT_H263}, "video", "H263"},
1350         {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
1351         {{1, AST_FORMAT_H264}, "video", "H264"},
1352 };
1353
1354 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1355    also, our own choices for dynamic payload types.  This is our master
1356    table for transmission */
1357 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
1358         [0] = {1, AST_FORMAT_ULAW},
1359 #ifdef USE_DEPRECATED_G726
1360         [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1361 #endif
1362         [3] = {1, AST_FORMAT_GSM},
1363         [4] = {1, AST_FORMAT_G723_1},
1364         [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
1365         [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
1366         [7] = {1, AST_FORMAT_LPC10},
1367         [8] = {1, AST_FORMAT_ALAW},
1368         [9] = {1, AST_FORMAT_G722},
1369         [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
1370         [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
1371         [13] = {0, AST_RTP_CN},
1372         [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
1373         [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
1374         [18] = {1, AST_FORMAT_G729A},
1375         [19] = {0, AST_RTP_CN},         /* Also used for CN */
1376         [26] = {1, AST_FORMAT_JPEG},
1377         [31] = {1, AST_FORMAT_H261},
1378         [34] = {1, AST_FORMAT_H263},
1379         [103] = {1, AST_FORMAT_H263_PLUS},
1380         [97] = {1, AST_FORMAT_ILBC},
1381         [99] = {1, AST_FORMAT_H264},
1382         [101] = {0, AST_RTP_DTMF},
1383         [110] = {1, AST_FORMAT_SPEEX},
1384         [111] = {1, AST_FORMAT_G726},
1385         [112] = {1, AST_FORMAT_G726_AAL2},
1386         [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
1387 };
1388
1389 void ast_rtp_pt_clear(struct ast_rtp* rtp) 
1390 {
1391         int i;
1392         if (!rtp)
1393                 return;
1394
1395         for (i = 0; i < MAX_RTP_PT; ++i) {
1396                 rtp->current_RTP_PT[i].isAstFormat = 0;
1397                 rtp->current_RTP_PT[i].code = 0;
1398         }
1399
1400         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1401         rtp->rtp_lookup_code_cache_code = 0;
1402         rtp->rtp_lookup_code_cache_result = 0;
1403 }
1404
1405 void ast_rtp_pt_default(struct ast_rtp* rtp) 
1406 {
1407         int i;
1408
1409         /* Initialize to default payload types */
1410         for (i = 0; i < MAX_RTP_PT; ++i) {
1411                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
1412                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
1413         }
1414
1415         rtp->rtp_lookup_code_cache_isAstFormat = 0;
1416         rtp->rtp_lookup_code_cache_code = 0;
1417         rtp->rtp_lookup_code_cache_result = 0;
1418 }
1419
1420 void ast_rtp_pt_copy(struct ast_rtp *dest, const struct ast_rtp *src)
1421 {
1422         unsigned int i;
1423
1424         for (i=0; i < MAX_RTP_PT; ++i) {
1425                 dest->current_RTP_PT[i].isAstFormat = 
1426                         src->current_RTP_PT[i].isAstFormat;
1427                 dest->current_RTP_PT[i].code = 
1428                         src->current_RTP_PT[i].code; 
1429         }
1430         dest->rtp_lookup_code_cache_isAstFormat = 0;
1431         dest->rtp_lookup_code_cache_code = 0;
1432         dest->rtp_lookup_code_cache_result = 0;
1433 }
1434
1435 /*! \brief Get channel driver interface structure */
1436 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1437 {
1438         struct ast_rtp_protocol *cur = NULL;
1439
1440         AST_LIST_LOCK(&protos);
1441         AST_LIST_TRAVERSE(&protos, cur, list) {
1442                 if (cur->type == chan->tech->type)
1443                         break;
1444         }
1445         AST_LIST_UNLOCK(&protos);
1446
1447         return cur;
1448 }
1449
1450 int ast_rtp_early_bridge(struct ast_channel *c0, struct ast_channel *c1)
1451 {
1452         // dest = c0, src = c1
1453         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1454         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1455         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1456         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1457         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED;
1458         int srccodec;
1459
1460         /* Lock channels */
1461         ast_channel_lock(c0);
1462         if (c1) {
1463                 while(ast_channel_trylock(c1)) {
1464                         ast_channel_unlock(c0);
1465                         usleep(1);
1466                         ast_channel_lock(c0);
1467                 }
1468         }
1469
1470         /* Find channel driver interfaces */
1471         destpr = get_proto(c0);
1472         if (c1)
1473                 srcpr = get_proto(c1);
1474         if (!destpr) {
1475                 if (option_debug)
1476                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c0->name);
1477                 ast_channel_unlock(c0);
1478                 if (c1)
1479                         ast_channel_unlock(c1);
1480                 return -1;
1481         }
1482         if (!srcpr) {
1483                 if (option_debug)
1484                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>");
1485                 ast_channel_unlock(c0);
1486                 if (c1)
1487                         ast_channel_unlock(c1);
1488                 return -1;
1489         }
1490
1491         /* Get audio and video interface (if native bridge is possible) */
1492         audio_dest_res = destpr->get_rtp_info(c0, &destp);
1493         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED;
1494         if (srcpr) {
1495                 audio_src_res = srcpr->get_rtp_info(c1, &srcp);
1496                 video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED;
1497         }
1498
1499         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1500         if (audio_dest_res != AST_RTP_TRY_NATIVE) {
1501                 /* Somebody doesn't want to play... */
1502                 ast_channel_unlock(c0);
1503                 if (c1)
1504                         ast_channel_unlock(c1);
1505                 return -1;
1506         }
1507         if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec)
1508                 srccodec = srcpr->get_codec(c1);
1509         else
1510                 srccodec = 0;
1511         /* Consider empty media as non-existant */
1512         if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr)
1513                 srcp = NULL;
1514         /* Bridge media early */
1515         if (destpr->set_rtp_peer(c0, srcp, vsrcp, srccodec, srcp ? ast_test_flag(srcp, FLAG_NAT_ACTIVE) : 0))
1516                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1517         ast_channel_unlock(c0);
1518         if (c1)
1519                 ast_channel_unlock(c1);
1520         if (option_debug)
1521                 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1522         return 0;
1523 }
1524
1525 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1526 {
1527         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1528         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1529         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1530         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1531         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 
1532         int srccodec;
1533
1534         /* Lock channels */
1535         ast_channel_lock(dest);
1536         while(ast_channel_trylock(src)) {
1537                 ast_channel_unlock(dest);
1538                 usleep(1);
1539                 ast_channel_lock(dest);
1540         }
1541
1542         /* Find channel driver interfaces */
1543         if (!(destpr = get_proto(dest))) {
1544                 if (option_debug)
1545                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1546                 ast_channel_unlock(dest);
1547                 ast_channel_unlock(src);
1548                 return 0;
1549         }
1550         if (!(srcpr = get_proto(src))) {
1551                 if (option_debug)
1552                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1553                 ast_channel_unlock(dest);
1554                 ast_channel_unlock(src);
1555                 return 0;
1556         }
1557
1558         /* Get audio and video interface (if native bridge is possible) */
1559         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1560         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1561         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1562         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1563
1564         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1565         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) {
1566                 /* Somebody doesn't want to play... */
1567                 ast_channel_unlock(dest);
1568                 ast_channel_unlock(src);
1569                 return 0;
1570         }
1571         ast_rtp_pt_copy(destp, srcp);
1572         if (vdestp && vsrcp)
1573                 ast_rtp_pt_copy(vdestp, vsrcp);
1574         if (srcpr->get_codec)
1575                 srccodec = srcpr->get_codec(src);
1576         else
1577                 srccodec = 0;
1578         if (media) {
1579                 /* Bridge early */
1580                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1581                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1582         }
1583         ast_channel_unlock(dest);
1584         ast_channel_unlock(src);
1585         if (option_debug)
1586                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1587         return 1;
1588 }
1589
1590 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1591  * By default, use the well-known value for this type (although it may 
1592  * still be set to a different value by a subsequent "a=rtpmap:" line)
1593  */
1594 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1595 {
1596         if (pt < 0 || pt > MAX_RTP_PT) 
1597                 return; /* bogus payload type */
1598
1599         if (static_RTP_PT[pt].code != 0) 
1600                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1601
1602
1603 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1604  * an SDP "a=rtpmap:" line.
1605  */
1606 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1607                              char *mimeType, char *mimeSubtype,
1608                              enum ast_rtp_options options)
1609 {
1610         unsigned int i;
1611
1612         if (pt < 0 || pt > MAX_RTP_PT) 
1613                 return; /* bogus payload type */
1614
1615         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1616                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1617                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1618                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1619                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1620                             mimeTypes[i].payloadType.isAstFormat &&
1621                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1622                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1623                         return;
1624                 }
1625         }
1626
1627
1628 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1629  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1630 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1631                              int* astFormats, int* nonAstFormats) {
1632         int pt;
1633
1634         *astFormats = *nonAstFormats = 0;
1635         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1636                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1637                         *astFormats |= rtp->current_RTP_PT[pt].code;
1638                 } else {
1639                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1640                 }
1641         }
1642 }
1643
1644 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1645 {
1646         struct rtpPayloadType result;
1647
1648         result.isAstFormat = result.code = 0;
1649         if (pt < 0 || pt > MAX_RTP_PT) 
1650                 return result; /* bogus payload type */
1651
1652         /* Start with negotiated codecs */
1653         result = rtp->current_RTP_PT[pt];
1654
1655         /* If it doesn't exist, check our static RTP type list, just in case */
1656         if (!result.code) 
1657                 result = static_RTP_PT[pt];
1658         return result;
1659 }
1660
1661 /*! \brief Looks up an RTP code out of our *static* outbound list */
1662 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
1663
1664         int pt;
1665
1666         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1667                 code == rtp->rtp_lookup_code_cache_code) {
1668
1669                 /* Use our cached mapping, to avoid the overhead of the loop below */
1670                 return rtp->rtp_lookup_code_cache_result;
1671         }
1672
1673         /* Check the dynamic list first */
1674         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1675                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1676                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1677                         rtp->rtp_lookup_code_cache_code = code;
1678                         rtp->rtp_lookup_code_cache_result = pt;
1679                         return pt;
1680                 }
1681         }
1682
1683         /* Then the static list */
1684         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1685                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1686                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1687                         rtp->rtp_lookup_code_cache_code = code;
1688                         rtp->rtp_lookup_code_cache_result = pt;
1689                         return pt;
1690                 }
1691         }
1692         return -1;
1693 }
1694
1695 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1696                                   enum ast_rtp_options options)
1697 {
1698         unsigned int i;
1699
1700         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1701                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1702                         if (isAstFormat &&
1703                             (code == AST_FORMAT_G726_AAL2) &&
1704                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1705                                 return "AAL2-G726-32";
1706                         else
1707                                 return mimeTypes[i].subtype;
1708                 }
1709         }
1710
1711         return "";
1712 }
1713
1714 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1715                                    const int isAstFormat, enum ast_rtp_options options)
1716 {
1717         int format;
1718         unsigned len;
1719         char *end = buf;
1720         char *start = buf;
1721
1722         if (!buf || !size)
1723                 return NULL;
1724
1725         snprintf(end, size, "0x%x (", capability);
1726
1727         len = strlen(end);
1728         end += len;
1729         size -= len;
1730         start = end;
1731
1732         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1733                 if (capability & format) {
1734                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1735
1736                         snprintf(end, size, "%s|", name);
1737                         len = strlen(end);
1738                         end += len;
1739                         size -= len;
1740                 }
1741         }
1742
1743         if (start == end)
1744                 snprintf(start, size, "nothing)"); 
1745         else if (size > 1)
1746                 *(end -1) = ')';
1747         
1748         return buf;
1749 }
1750
1751 /*! \brief Open RTP or RTCP socket for a session */
1752 static int rtp_socket(void)
1753 {
1754         int s;
1755         long flags;
1756         s = socket(AF_INET, SOCK_DGRAM, 0);
1757         if (s > -1) {
1758                 flags = fcntl(s, F_GETFL);
1759                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1760 #ifdef SO_NO_CHECK
1761                 if (nochecksums)
1762                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1763 #endif
1764         }
1765         return s;
1766 }
1767
1768 /*!
1769  * \brief Initialize a new RTCP session.
1770  * 
1771  * \returns The newly initialized RTCP session.
1772  */
1773 static struct ast_rtcp *ast_rtcp_new(void)
1774 {
1775         struct ast_rtcp *rtcp;
1776
1777         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1778                 return NULL;
1779         rtcp->s = rtp_socket();
1780         rtcp->us.sin_family = AF_INET;
1781         rtcp->them.sin_family = AF_INET;
1782
1783         if (rtcp->s < 0) {
1784                 free(rtcp);
1785                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1786                 return NULL;
1787         }
1788
1789         return rtcp;
1790 }
1791
1792 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1793 {
1794         struct ast_rtp *rtp;
1795         int x;
1796         int first;
1797         int startplace;
1798         
1799         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1800                 return NULL;
1801         rtp->them.sin_family = AF_INET;
1802         rtp->us.sin_family = AF_INET;
1803         rtp->s = rtp_socket();
1804         rtp->ssrc = ast_random();
1805         rtp->seqno = ast_random() & 0xffff;
1806         ast_set_flag(rtp, FLAG_HAS_DTMF);
1807         if (rtp->s < 0) {
1808                 free(rtp);
1809                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1810                 return NULL;
1811         }
1812         if (sched && rtcpenable) {
1813                 rtp->sched = sched;
1814                 rtp->rtcp = ast_rtcp_new();
1815         }
1816         
1817         /* Select a random port number in the range of possible RTP */
1818         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1819         x = x & ~1;
1820         /* Save it for future references. */
1821         startplace = x;
1822         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1823         for (;;) {
1824                 /* Must be an even port number by RTP spec */
1825                 rtp->us.sin_port = htons(x);
1826                 rtp->us.sin_addr = addr;
1827
1828                 /* If there's rtcp, initialize it as well. */
1829                 if (rtp->rtcp) {
1830                         rtp->rtcp->us.sin_port = htons(x + 1);
1831                         rtp->rtcp->us.sin_addr = addr;
1832                 }
1833                 /* Try to bind it/them. */
1834                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1835                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1836                         break;
1837                 if (!first) {
1838                         /* Primary bind succeeded! Gotta recreate it */
1839                         close(rtp->s);
1840                         rtp->s = rtp_socket();
1841                 }
1842                 if (errno != EADDRINUSE) {
1843                         /* We got an error that wasn't expected, abort! */
1844                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1845                         close(rtp->s);
1846                         if (rtp->rtcp) {
1847                                 close(rtp->rtcp->s);
1848                                 free(rtp->rtcp);
1849                         }
1850                         free(rtp);
1851                         return NULL;
1852                 }
1853                 /* The port was used, increment it (by two). */
1854                 x += 2;
1855                 /* Did we go over the limit ? */
1856                 if (x > rtpend)
1857                         /* then, start from the begingig. */
1858                         x = (rtpstart + 1) & ~1;
1859                 /* Check if we reached the place were we started. */
1860                 if (x == startplace) {
1861                         /* If so, there's no ports available. */
1862                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1863                         close(rtp->s);
1864                         if (rtp->rtcp) {
1865                                 close(rtp->rtcp->s);
1866                                 free(rtp->rtcp);
1867                         }
1868                         free(rtp);
1869                         return NULL;
1870                 }
1871         }
1872         rtp->sched = sched;
1873         rtp->io = io;
1874         if (callbackmode) {
1875                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1876                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
1877         }
1878         ast_rtp_pt_default(rtp);
1879         return rtp;
1880 }
1881
1882 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1883 {
1884         struct in_addr ia;
1885
1886         memset(&ia, 0, sizeof(ia));
1887         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1888 }
1889
1890 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1891 {
1892         int res;
1893
1894         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1895                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1896         return res;
1897 }
1898
1899 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1900 {
1901         rtp->them.sin_port = them->sin_port;
1902         rtp->them.sin_addr = them->sin_addr;
1903         if (rtp->rtcp) {
1904                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1905                 rtp->rtcp->them.sin_addr = them->sin_addr;
1906         }
1907         rtp->rxseqno = 0;
1908 }
1909
1910 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1911 {
1912         if ((them->sin_family != AF_INET) ||
1913                 (them->sin_port != rtp->them.sin_port) ||
1914                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1915                 them->sin_family = AF_INET;
1916                 them->sin_port = rtp->them.sin_port;
1917                 them->sin_addr = rtp->them.sin_addr;
1918                 return 1;
1919         }
1920         return 0;
1921 }
1922
1923 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1924 {
1925         *us = rtp->us;
1926 }
1927
1928 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
1929 {
1930         return rtp->bridged;
1931 }
1932
1933 void ast_rtp_stop(struct ast_rtp *rtp)
1934 {
1935         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
1936                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
1937                 rtp->rtcp->schedid = -1;
1938         }
1939
1940         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1941         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1942         if (rtp->rtcp) {
1943                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
1944                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
1945         }
1946         
1947         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
1948 }
1949
1950 void ast_rtp_reset(struct ast_rtp *rtp)
1951 {
1952         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1953         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1954         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1955         rtp->lastts = 0;
1956         rtp->lastdigitts = 0;
1957         rtp->lastrxts = 0;
1958         rtp->lastividtimestamp = 0;
1959         rtp->lastovidtimestamp = 0;
1960         rtp->lasteventseqn = 0;
1961         rtp->lasteventendseqn = 0;
1962         rtp->lasttxformat = 0;
1963         rtp->lastrxformat = 0;
1964         rtp->dtmfcount = 0;
1965         rtp->dtmfduration = 0;
1966         rtp->seqno = 0;
1967         rtp->rxseqno = 0;
1968 }
1969
1970 char *ast_rtp_get_quality(struct ast_rtp *rtp)
1971 {
1972         /*
1973         *ssrc          our ssrc
1974         *themssrc      their ssrc
1975         *lp            lost packets
1976         *rxjitter      our calculated jitter(rx)
1977         *rxcount       no. received packets
1978         *txjitter      reported jitter of the other end
1979         *txcount       transmitted packets
1980         *rlp           remote lost packets
1981         */
1982         
1983         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);
1984         
1985         return rtp->rtcp->quality;
1986 }
1987
1988 void ast_rtp_destroy(struct ast_rtp *rtp)
1989 {
1990         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
1991                 /*Print some info on the call here */
1992                 ast_verbose("  RTP-stats\n");
1993                 ast_verbose("* Our Receiver:\n");
1994                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
1995                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
1996                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
1997                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
1998                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
1999                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2000                 ast_verbose("* Our Sender:\n");
2001                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2002                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2003                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2004                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2005                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2006                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2007         }
2008
2009         if (rtp->smoother)
2010                 ast_smoother_free(rtp->smoother);
2011         if (rtp->ioid)
2012                 ast_io_remove(rtp->io, rtp->ioid);
2013         if (rtp->s > -1)
2014                 close(rtp->s);
2015         if (rtp->rtcp) {
2016                 if (rtp->rtcp->schedid > 0)
2017                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2018                 close(rtp->rtcp->s);
2019                 free(rtp->rtcp);
2020                 rtp->rtcp=NULL;
2021         }
2022         free(rtp);
2023 }
2024
2025 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2026 {
2027         struct timeval t;
2028         long ms;
2029         if (ast_tvzero(rtp->txcore)) {
2030                 rtp->txcore = ast_tvnow();
2031                 /* Round to 20ms for nice, pretty timestamps */
2032                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2033         }
2034         /* Use previous txcore if available */
2035         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2036         ms = ast_tvdiff_ms(t, rtp->txcore);
2037         if (ms < 0)
2038                 ms = 0;
2039         /* Use what we just got for next time */
2040         rtp->txcore = t;
2041         return (unsigned int) ms;
2042 }
2043
2044 /*! \brief Send begin frames for DTMF */
2045 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2046 {
2047         unsigned int *rtpheader;
2048         int hdrlen = 12, res = 0, i = 0, payload = 0;
2049         char data[256];
2050
2051         if ((digit <= '9') && (digit >= '0'))
2052                 digit -= '0';
2053         else if (digit == '*')
2054                 digit = 10;
2055         else if (digit == '#')
2056                 digit = 11;
2057         else if ((digit >= 'A') && (digit <= 'D'))
2058                 digit = digit - 'A' + 12;
2059         else if ((digit >= 'a') && (digit <= 'd'))
2060                 digit = digit - 'a' + 12;
2061         else {
2062                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2063                 return 0;
2064         }
2065
2066         /* If we have no peer, return immediately */    
2067         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2068                 return 0;
2069
2070         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2071
2072         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2073         rtp->send_duration = 160;
2074         
2075         /* Get a pointer to the header */
2076         rtpheader = (unsigned int *)data;
2077         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2078         rtpheader[1] = htonl(rtp->lastdigitts);
2079         rtpheader[2] = htonl(rtp->ssrc); 
2080
2081         for (i = 0; i < 2; i++) {
2082                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2083                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2084                 if (res < 0) 
2085                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2086                                 ast_inet_ntoa(rtp->them.sin_addr),
2087                                 ntohs(rtp->them.sin_port), strerror(errno));
2088                 if (rtp_debug_test_addr(&rtp->them))
2089                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2090                                     ast_inet_ntoa(rtp->them.sin_addr),
2091                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2092                 /* Increment sequence number */
2093                 rtp->seqno++;
2094                 /* Increment duration */
2095                 rtp->send_duration += 160;
2096                 /* Clear marker bit and set seqno */
2097                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2098         }
2099
2100         /* Since we received a begin, we can safely store the digit and disable any compensation */
2101         rtp->send_digit = digit;
2102         rtp->send_payload = payload;
2103
2104         return 0;
2105 }
2106
2107 /*! \brief Send continuation frame for DTMF */
2108 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2109 {
2110         unsigned int *rtpheader;
2111         int hdrlen = 12, res = 0;
2112         char data[256];
2113
2114         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2115                 return 0;
2116
2117         /* Setup packet to send */
2118         rtpheader = (unsigned int *)data;
2119         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2120         rtpheader[1] = htonl(rtp->lastdigitts);
2121         rtpheader[2] = htonl(rtp->ssrc);
2122         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2123         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2124         
2125         /* Transmit */
2126         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2127         if (res < 0)
2128                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2129                         ast_inet_ntoa(rtp->them.sin_addr),
2130                         ntohs(rtp->them.sin_port), strerror(errno));
2131         if (rtp_debug_test_addr(&rtp->them))
2132                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2133                             ast_inet_ntoa(rtp->them.sin_addr),
2134                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2135
2136         /* Increment sequence number */
2137         rtp->seqno++;
2138         /* Increment duration */
2139         rtp->send_duration += 160;
2140
2141         return 0;
2142 }
2143
2144 /*! \brief Send end packets for DTMF */
2145 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2146 {
2147         unsigned int *rtpheader;
2148         int hdrlen = 12, res = 0, i = 0;
2149         char data[256];
2150         
2151         /* If no address, then bail out */
2152         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2153                 return 0;
2154         
2155         if ((digit <= '9') && (digit >= '0'))
2156                 digit -= '0';
2157         else if (digit == '*')
2158                 digit = 10;
2159         else if (digit == '#')
2160                 digit = 11;
2161         else if ((digit >= 'A') && (digit <= 'D'))
2162                 digit = digit - 'A' + 12;
2163         else if ((digit >= 'a') && (digit <= 'd'))
2164                 digit = digit - 'a' + 12;
2165         else {
2166                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2167                 return 0;
2168         }
2169
2170         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2171
2172         rtpheader = (unsigned int *)data;
2173         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2174         rtpheader[1] = htonl(rtp->lastdigitts);
2175         rtpheader[2] = htonl(rtp->ssrc);
2176         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2177         /* Set end bit */
2178         rtpheader[3] |= htonl((1 << 23));
2179         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2180         /* Send 3 termination packets */
2181         for (i = 0; i < 3; i++) {
2182                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2183                 if (res < 0)
2184                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2185                                 ast_inet_ntoa(rtp->them.sin_addr),
2186                                 ntohs(rtp->them.sin_port), strerror(errno));
2187                 if (rtp_debug_test_addr(&rtp->them))
2188                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2189                                     ast_inet_ntoa(rtp->them.sin_addr),
2190                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2191         }
2192         rtp->send_digit = 0;
2193         /* Increment lastdigitts */
2194         rtp->lastdigitts += 960;
2195         rtp->seqno++;
2196
2197         return res;
2198 }
2199
2200 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2201 int ast_rtcp_send_h261fur(void *data)
2202 {
2203         struct ast_rtp *rtp = data;
2204         int res;
2205
2206         rtp->rtcp->sendfur = 1;
2207         res = ast_rtcp_write(data);
2208         
2209         return res;
2210 }
2211
2212 /*! \brief Send RTCP sender's report */
2213 static int ast_rtcp_write_sr(void *data)
2214 {
2215         struct ast_rtp *rtp = data;
2216         int res;
2217         int len = 0;
2218         struct timeval now;
2219         unsigned int now_lsw;
2220         unsigned int now_msw;
2221         unsigned int *rtcpheader;
2222         unsigned int lost;
2223         unsigned int extended;
2224         unsigned int expected;
2225         unsigned int expected_interval;
2226         unsigned int received_interval;
2227         int lost_interval;
2228         int fraction;
2229         struct timeval dlsr;
2230         char bdata[512];
2231
2232         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2233         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2234                 return 0;
2235         
2236         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2237                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2238                 if (rtp->rtcp->schedid > 0)
2239                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2240                 rtp->rtcp->schedid = -1;
2241                 return 0;
2242         }
2243
2244         gettimeofday(&now, NULL);
2245         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2246         rtcpheader = (unsigned int *)bdata;
2247         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2248         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2249         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2250         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2251         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2252         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2253         len += 28;
2254         
2255         extended = rtp->cycles + rtp->lastrxseqno;
2256         expected = extended - rtp->seedrxseqno + 1;
2257         if (rtp->rxcount > expected) 
2258                 expected += rtp->rxcount - expected;
2259         lost = expected - rtp->rxcount;
2260         expected_interval = expected - rtp->rtcp->expected_prior;
2261         rtp->rtcp->expected_prior = expected;
2262         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2263         rtp->rtcp->received_prior = rtp->rxcount;
2264         lost_interval = expected_interval - received_interval;
2265         if (expected_interval == 0 || lost_interval <= 0)
2266                 fraction = 0;
2267         else
2268                 fraction = (lost_interval << 8) / expected_interval;
2269         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2270         rtcpheader[7] = htonl(rtp->themssrc);
2271         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2272         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2273         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2274         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2275         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2276         len += 24;
2277         
2278         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2279
2280         if (rtp->rtcp->sendfur) {
2281                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2282                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2283                 len += 8;
2284                 rtp->rtcp->sendfur = 0;
2285         }
2286         
2287         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2288         /* it can change mid call, and SDES can't) */
2289         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2290         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2291         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2292         len += 12;
2293         
2294         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2295         if (res < 0) {
2296                 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));
2297                 if (rtp->rtcp->schedid > 0)
2298                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2299                 rtp->rtcp->schedid = -1;
2300                 return 0;
2301         }
2302         
2303         /* FIXME Don't need to get a new one */
2304         gettimeofday(&rtp->rtcp->txlsr, NULL);
2305         rtp->rtcp->sr_count++;
2306
2307         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2308         
2309         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2310                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2311                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2312                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2313                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2314                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2315                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2316                 ast_verbose("  Report block:\n");
2317                 ast_verbose("  Fraction lost: %u\n", fraction);
2318                 ast_verbose("  Cumulative loss: %u\n", lost);
2319                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2320                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2321                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2322         }
2323         return res;
2324 }
2325
2326 /*! \brief Send RTCP recipient's report */
2327 static int ast_rtcp_write_rr(void *data)
2328 {
2329         struct ast_rtp *rtp = data;
2330         int res;
2331         int len = 32;
2332         unsigned int lost;
2333         unsigned int extended;
2334         unsigned int expected;
2335         unsigned int expected_interval;
2336         unsigned int received_interval;
2337         int lost_interval;
2338         struct timeval now;
2339         unsigned int *rtcpheader;
2340         char bdata[1024];
2341         struct timeval dlsr;
2342         int fraction;
2343
2344         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2345                 return 0;
2346           
2347         if (!rtp->rtcp->them.sin_addr.s_addr) {
2348                 ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno));
2349                 if (rtp->rtcp->schedid > 0)
2350                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2351                 rtp->rtcp->schedid = -1;
2352                 return 0;
2353         }
2354
2355         extended = rtp->cycles + rtp->lastrxseqno;
2356         expected = extended - rtp->seedrxseqno + 1;
2357         lost = expected - rtp->rxcount;
2358         expected_interval = expected - rtp->rtcp->expected_prior;
2359         rtp->rtcp->expected_prior = expected;
2360         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2361         rtp->rtcp->received_prior = rtp->rxcount;
2362         lost_interval = expected_interval - received_interval;
2363         if (expected_interval == 0 || lost_interval <= 0)
2364                 fraction = 0;
2365         else
2366                 fraction = (lost_interval << 8) / expected_interval;
2367         gettimeofday(&now, NULL);
2368         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2369         rtcpheader = (unsigned int *)bdata;
2370         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2371         rtcpheader[1] = htonl(rtp->ssrc);
2372         rtcpheader[2] = htonl(rtp->themssrc);
2373         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2374         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2375         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2376         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2377         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2378
2379         if (rtp->rtcp->sendfur) {
2380                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2381                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2382                 len += 8;
2383                 rtp->rtcp->sendfur = 0;
2384         }
2385
2386         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2387         it can change mid call, and SDES can't) */
2388         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2389         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2390         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2391         len += 12;
2392         
2393         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2394
2395         if (res < 0) {
2396                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2397                 /* Remove the scheduler */
2398                 if (rtp->rtcp->schedid > 0)
2399                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2400                 rtp->rtcp->schedid = -1;
2401                 return 0;
2402         }
2403
2404         rtp->rtcp->rr_count++;
2405
2406         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2407                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2408                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2409                         "  IA jitter: %.4f\n" 
2410                         "  Their last SR: %u\n" 
2411                         "  DLSR: %4.4f (sec)\n\n",
2412                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2413                         ntohs(rtp->rtcp->them.sin_port),
2414                         rtp->ssrc, rtp->themssrc, fraction, lost,
2415                         rtp->rxjitter,
2416                         rtp->rtcp->themrxlsr,
2417                         (double)(ntohl(rtcpheader[7])/65536.0));
2418         }
2419
2420         return res;
2421 }
2422
2423 /*! \brief Write and RTCP packet to the far end
2424  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2425  * RR is sent if we have not sent any rtp packets in the previous interval */
2426 static int ast_rtcp_write(void *data)
2427 {
2428         struct ast_rtp *rtp = data;
2429         int res;
2430         
2431         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2432                 res = ast_rtcp_write_sr(data);
2433         else
2434                 res = ast_rtcp_write_rr(data);
2435         
2436         return res;
2437 }
2438
2439 /*! \brief generate comfort noice (CNG) */
2440 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2441 {
2442         unsigned int *rtpheader;
2443         int hdrlen = 12;
2444         int res;
2445         int payload;
2446         char data[256];
2447         level = 127 - (level & 0x7f);
2448         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2449
2450         /* If we have no peer, return immediately */    
2451         if (!rtp->them.sin_addr.s_addr)
2452                 return 0;
2453
2454         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2455
2456         /* Get a pointer to the header */
2457         rtpheader = (unsigned int *)data;
2458         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2459         rtpheader[1] = htonl(rtp->lastts);
2460         rtpheader[2] = htonl(rtp->ssrc); 
2461         data[12] = level;
2462         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2463                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2464                 if (res <0) 
2465                         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));
2466                 if (rtp_debug_test_addr(&rtp->them))
2467                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %u, len %d)\n"
2468                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2469                    
2470         }
2471         return 0;
2472 }
2473
2474 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2475 {
2476         unsigned char *rtpheader;
2477         int hdrlen = 12;
2478         int res;
2479         unsigned int ms;
2480         int pred;
2481         int mark = 0;
2482
2483         ms = calc_txstamp(rtp, &f->delivery);
2484         /* Default prediction */
2485         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2486                 pred = rtp->lastts + f->samples;
2487
2488                 /* Re-calculate last TS */
2489                 rtp->lastts = rtp->lastts + ms * 8;
2490                 if (ast_tvzero(f->delivery)) {
2491                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2492                            and if so, go with our prediction */
2493                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2494                                 rtp->lastts = pred;
2495                         else {
2496                                 if (option_debug > 2)
2497                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2498                                 mark = 1;
2499                         }
2500                 }
2501         } else {
2502                 mark = f->subclass & 0x1;
2503                 pred = rtp->lastovidtimestamp + f->samples;
2504                 /* Re-calculate last TS */
2505                 rtp->lastts = rtp->lastts + ms * 90;
2506                 /* If it's close to our prediction, go for it */
2507                 if (ast_tvzero(f->delivery)) {
2508                         if (abs(rtp->lastts - pred) < 7200) {
2509                                 rtp->lastts = pred;
2510                                 rtp->lastovidtimestamp += f->samples;
2511                         } else {
2512                                 if (option_debug > 2)
2513                                         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);
2514                                 rtp->lastovidtimestamp = rtp->lastts;
2515                         }
2516                 }
2517         }
2518         /* If the timestamp for non-digit packets has moved beyond the timestamp
2519            for digits, update the digit timestamp.
2520         */
2521         if (rtp->lastts > rtp->lastdigitts)
2522                 rtp->lastdigitts = rtp->lastts;
2523
2524         if (f->has_timing_info)
2525                 rtp->lastts = f->ts * 8;
2526
2527         /* Get a pointer to the header */
2528         rtpheader = (unsigned char *)(f->data - hdrlen);
2529
2530         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2531         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2532         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2533
2534         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2535                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2536                 if (res <0) {
2537                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2538                                 if (option_debug)
2539                                         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));
2540                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2541                                 /* Only give this error message once if we are not RTP debugging */
2542                                 if (option_debug || rtpdebug)
2543                                         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));
2544                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2545                         }
2546                 } else {
2547                         rtp->txcount++;
2548                         rtp->txoctetcount +=(res - hdrlen);
2549                         
2550                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2551                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2552                 }
2553                                 
2554                 if (rtp_debug_test_addr(&rtp->them))
2555                         ast_verbose("Sent RTP packet to      %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2556                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2557         }
2558
2559         rtp->seqno++;
2560
2561         return 0;
2562 }
2563
2564 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2565 {
2566         int x;
2567         for (x = 0; x < 32; x++) {  /* Ugly way */
2568                 rtp->pref.order[x] = prefs->order[x];
2569                 rtp->pref.framing[x] = prefs->framing[x];
2570         }
2571         if (rtp->smoother)
2572                 ast_smoother_free(rtp->smoother);
2573         rtp->smoother = NULL;
2574         return 0;
2575 }
2576
2577 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2578 {
2579         return &rtp->pref;
2580 }
2581
2582 int ast_rtp_codec_getformat(int pt)
2583 {
2584         if (pt < 0 || pt > MAX_RTP_PT)
2585                 return 0; /* bogus payload type */
2586
2587         if (static_RTP_PT[pt].isAstFormat)
2588                 return static_RTP_PT[pt].code;
2589         else
2590                 return 0;
2591 }
2592
2593 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2594 {
2595         struct ast_frame *f;
2596         int codec;
2597         int hdrlen = 12;
2598         int subclass;
2599         
2600
2601         /* If we have no peer, return immediately */    
2602         if (!rtp->them.sin_addr.s_addr)
2603                 return 0;
2604
2605         /* If there is no data length, return immediately */
2606         if (!_f->datalen) 
2607                 return 0;
2608         
2609         /* Make sure we have enough space for RTP header */
2610         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2611                 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2612                 return -1;
2613         }
2614
2615         subclass = _f->subclass;
2616         if (_f->frametype == AST_FRAME_VIDEO)
2617                 subclass &= ~0x1;
2618
2619         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2620         if (codec < 0) {
2621                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2622                 return -1;
2623         }
2624
2625         if (rtp->lasttxformat != subclass) {
2626                 /* New format, reset the smoother */
2627                 if (option_debug)
2628                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2629                 rtp->lasttxformat = subclass;
2630                 if (rtp->smoother)
2631                         ast_smoother_free(rtp->smoother);
2632                 rtp->smoother = NULL;
2633         }
2634
2635         if (!rtp->smoother) {
2636                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2637                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2638                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2639                                 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));
2640                                 return -1;
2641                         }
2642                         if (fmt.flags)
2643                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2644                         if (option_debug)
2645                                 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));
2646                 }
2647         }
2648         if (rtp->smoother) {
2649                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2650                         ast_smoother_feed_be(rtp->smoother, _f);
2651                 } else {
2652                         ast_smoother_feed(rtp->smoother, _f);
2653                 }
2654
2655                 while((f = ast_smoother_read(rtp->smoother)))
2656                         ast_rtp_raw_write(rtp, f, codec);
2657         } else {
2658                 /* Don't buffer outgoing frames; send them one-per-packet: */
2659                 if (_f->offset < hdrlen) {
2660                         f = ast_frdup(_f);
2661                 } else {
2662                         f = _f;
2663                 }
2664                 ast_rtp_raw_write(rtp, f, codec);
2665         }
2666                 
2667         return 0;
2668 }
2669
2670 /*! \brief Unregister interface to channel driver */
2671 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2672 {
2673         AST_LIST_LOCK(&protos);
2674         AST_LIST_REMOVE(&protos, proto, list);
2675         AST_LIST_UNLOCK(&protos);
2676 }
2677
2678 /*! \brief Register interface to channel driver */
2679 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2680 {
2681         struct ast_rtp_protocol *cur;
2682
2683         AST_LIST_LOCK(&protos);
2684         AST_LIST_TRAVERSE(&protos, cur, list) { 
2685                 if (!strcmp(cur->type, proto->type)) {
2686                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2687                         AST_LIST_UNLOCK(&protos);
2688                         return -1;
2689                 }
2690         }
2691         AST_LIST_INSERT_HEAD(&protos, proto, list);
2692         AST_LIST_UNLOCK(&protos);
2693         
2694         return 0;
2695 }
2696
2697 /*! \brief Bridge loop for true native bridge (reinvite) */
2698 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)
2699 {
2700         struct ast_frame *fr = NULL;
2701         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2702         int oldcodec0 = codec0, oldcodec1 = codec1;
2703         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2704         struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2705
2706         /* Set it up so audio goes directly between the two endpoints */
2707
2708         /* Test the first channel */
2709         if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2710                 ast_rtp_get_peer(p1, &ac1);
2711                 if (vp1)
2712                         ast_rtp_get_peer(vp1, &vac1);
2713         } else
2714                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2715         
2716         /* Test the second channel */
2717         if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2718                 ast_rtp_get_peer(p0, &ac0);
2719                 if (vp0)
2720                         ast_rtp_get_peer(vp0, &vac0);
2721         } else
2722                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2723
2724         /* Now we can unlock and move into our loop */
2725         ast_channel_unlock(c0);
2726         ast_channel_unlock(c1);
2727
2728         /* Throw our channels into the structure and enter the loop */
2729         cs[0] = c0;
2730         cs[1] = c1;
2731         cs[2] = NULL;
2732         for (;;) {
2733                 /* Check if anything changed */
2734                 if ((c0->tech_pvt != pvt0) ||
2735                     (c1->tech_pvt != pvt1) ||
2736                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2737                         if (option_debug)
2738                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2739                         if (c0->tech_pvt == pvt0)
2740                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2741                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2742                         if (c1->tech_pvt == pvt1)
2743                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2744                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2745                         return AST_BRIDGE_RETRY;
2746                 }
2747
2748                 /* Check if they have changed their address */
2749                 ast_rtp_get_peer(p1, &t1);
2750                 if (vp1)
2751                         ast_rtp_get_peer(vp1, &vt1);
2752                 if (pr1->get_codec)
2753                         codec1 = pr1->get_codec(c1);
2754                 ast_rtp_get_peer(p0, &t0);
2755                 if (vp0)
2756                         ast_rtp_get_peer(vp0, &vt0);
2757                 if (pr0->get_codec)
2758                         codec0 = pr0->get_codec(c0);
2759                 if ((inaddrcmp(&t1, &ac1)) ||
2760                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2761                     (codec1 != oldcodec1)) {
2762                         if (option_debug > 1) {
2763                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2764                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2765                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2766                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2767                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2768                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2769                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2770                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2771                         }
2772                         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)))
2773                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2774                         memcpy(&ac1, &t1, sizeof(ac1));
2775                         memcpy(&vac1, &vt1, sizeof(vac1));
2776                         oldcodec1 = codec1;
2777                 }
2778                 if ((inaddrcmp(&t0, &ac0)) ||
2779                     (vp0 && inaddrcmp(&vt0, &vac0))) {
2780                         if (option_debug > 1) {
2781                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2782                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2783                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2784                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2785                         }
2786                         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)))
2787                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2788                         memcpy(&ac0, &t0, sizeof(ac0));
2789                         memcpy(&vac0, &vt0, sizeof(vac0));
2790                         oldcodec0 = codec0;
2791                 }
2792
2793                 /* Wait for frame to come in on the channels */
2794                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2795                         if (!timeoutms)
2796                                 return AST_BRIDGE_RETRY;
2797                         if (option_debug)
2798                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2799                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2800                                 break;
2801                         continue;
2802                 }
2803                 fr = ast_read(who);
2804                 other = (who == c0) ? c1 : c0;
2805                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2806                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2807                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2808                         /* Break out of bridge */
2809                         *fo = fr;
2810                         *rc = who;
2811                         if (option_debug)
2812                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2813                         if (c0->tech_pvt == pvt0)
2814                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2815                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2816                         if (c1->tech_pvt == pvt1)
2817                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2818                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2819                         return AST_BRIDGE_COMPLETE;
2820                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2821                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2822                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2823                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2824                                 ast_indicate(other, fr->subclass);
2825                                 ast_frfree(fr);
2826                         } else {
2827                                 *fo = fr;
2828                                 *rc = who;
2829                                 if (option_debug)
2830                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2831                                 return AST_BRIDGE_COMPLETE;
2832                         }
2833                 } else {
2834                         if ((fr->frametype == AST_FRAME_DTMF) ||
2835                             (fr->frametype == AST_FRAME_VOICE) ||
2836                             (fr->frametype == AST_FRAME_VIDEO)) {
2837                                 ast_write(other, fr);
2838                         }
2839                         ast_frfree(fr);
2840                 }
2841                 /* Swap priority */
2842                 cs[2] = cs[0];
2843                 cs[0] = cs[1];
2844                 cs[1] = cs[2];
2845         }
2846
2847         return AST_BRIDGE_FAILED;
2848 }
2849
2850 /*! \brief P2P RTP/RTCP Callback */
2851 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
2852 {
2853         int res = 0, hdrlen = 12;
2854         struct sockaddr_in sin;
2855         socklen_t len;
2856         unsigned int *header;
2857         struct ast_rtp *rtp = cbdata;
2858         int is_rtp = 0, is_rtcp = 0;
2859
2860         if (!rtp)
2861                 return 1;
2862
2863         len = sizeof(sin);
2864         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
2865                 return 1;
2866
2867         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
2868
2869         /* Determine what this file descriptor is for */
2870         if (rtp->s == fd)
2871                 is_rtp = 1;
2872         else if (rtp->rtcp && rtp->rtcp->s == fd)
2873                 is_rtcp = 1;
2874
2875         /* If NAT support is turned on, then see if we need to change their address */
2876         if (rtp->nat) {
2877                 /* If this is for RTP, check that - if it's for RTCP, check that */
2878                 if (is_rtp) {
2879                         if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2880                             (rtp->them.sin_port != sin.sin_port)) {
2881                                 rtp->them = sin;
2882                                 rtp->rxseqno = 0;
2883                                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2884                                 if (option_debug || rtpdebug)
2885                                         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));
2886                         }
2887                 } else if (is_rtcp) {
2888                         if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2889                             (rtp->rtcp->them.sin_port != sin.sin_port)) {
2890                                 rtp->rtcp->them = sin;
2891                                 if (option_debug || rtpdebug)
2892                                         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));
2893                         }
2894                 }
2895         }
2896
2897         /* If this came from the RTP stream, write out via RTP - if it's RTCP, write out via RTCP */
2898         if (ast_rtp_get_bridged(rtp)) {
2899                 if (is_rtp)
2900                         bridge_p2p_rtp_write(rtp, header, res, hdrlen);
2901                 else if (is_rtcp)
2902                         bridge_p2p_rtcp_write(rtp, header, res);
2903         }
2904
2905         return 1;
2906 }
2907
2908 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
2909 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2910 {
2911         /* If we need DTMF or we have no IO structure, then we can't do direct callback */
2912         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || !rtp->io)
2913                 return 0;
2914
2915         /* If the RTP structure is already in callback mode, remove it temporarily */
2916         if (rtp->ioid) {
2917                 ast_io_remove(rtp->io, rtp->ioid);
2918                 rtp->ioid = NULL;
2919         }
2920
2921         /* Steal the file descriptors from the channel and stash them away */
2922         fds[0] = chan->fds[0];
2923         fds[1] = chan->fds[1];
2924         chan->fds[0] = -1;
2925         chan->fds[1] = -1;
2926
2927         /* Now, fire up callback mode */
2928         iod[0] = ast_io_add(rtp->io, fds[0], p2p_rtp_callback, AST_IO_IN, rtp);
2929         if (fds[1] >= 0)
2930                 iod[1] = ast_io_add(rtp->io, fds[1], p2p_rtp_callback, AST_IO_IN, rtp);
2931
2932         return 1;
2933 }
2934
2935 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
2936 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2937 {
2938         ast_channel_lock(chan);
2939         /* Remove the callback from the IO context */
2940         ast_io_remove(rtp->io, iod[0]);
2941         ast_io_remove(rtp->io, iod[1]);
2942         /* Restore file descriptors */
2943         chan->fds[0] = fds[0];
2944         chan->fds[1] = fds[1];
2945         ast_channel_unlock(chan);
2946         /* Restore callback mode if previously used */
2947         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
2948             rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2949         return 0;
2950 }
2951
2952 /*! \brief Bridge loop for partial native bridge (packet2packet) */
2953 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)
2954 {
2955         struct ast_frame *fr = NULL;
2956         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2957         int p0_fds[2] = {-1, -1}, p1_fds[2] = {-1, -1};
2958         int *p0_iod[2] = {NULL, }, *p1_iod[2] = {NULL, };
2959         int p0_callback = 0, p1_callback = 0;
2960         enum ast_bridge_result res = AST_BRIDGE_FAILED;
2961
2962         /* Okay, setup each RTP structure to do P2P forwarding */
2963         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
2964         p0->bridged = p1;
2965         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
2966         p1->bridged = p0;
2967         if (vp0) {
2968                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
2969                 vp0->bridged = vp1;
2970                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
2971                 vp1->bridged = vp0;
2972         }
2973
2974         /* Activate callback modes if possible */
2975         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
2976         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
2977
2978         /* Now let go of the channel locks and be on our way */
2979         ast_channel_unlock(c0);
2980         ast_channel_unlock(c1);
2981
2982         /* Go into a loop forwarding frames until we don't need to anymore */
2983         cs[0] = c0;
2984         cs[1] = c1;
2985         cs[2] = NULL;
2986         for (;;) {
2987                 /* Check if anything changed */
2988                 if ((c0->tech_pvt != pvt0) ||
2989                     (c1->tech_pvt != pvt1) ||
2990                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2991                         if (option_debug)
2992                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2993                         res = AST_BRIDGE_RETRY;
2994                         break;
2995                 }
2996                 /* Wait on a channel to feed us a frame */
2997                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2998                         if (!timeoutms) {
2999                                 res = AST_BRIDGE_RETRY;
3000                                 break;
3001                         }
3002                         if (option_debug)
3003                                 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
3004                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3005                                 break;
3006                         continue;
3007                 }
3008                 /* Read in frame from channel */
3009                 fr = ast_read(who);
3010                 other = (who == c0) ? c1 : c0;
3011                 /* Dependong on the frame we may need to break out of our bridge */
3012                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3013                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3014                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3015                         /* Record received frame and who */
3016                         *fo = fr;
3017                         *rc = who;
3018                         if (option_debug)
3019                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3020                         res = AST_BRIDGE_COMPLETE;
3021                         break;
3022                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3023                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3024                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3025                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3026                                 /* If we are going on hold, then break callback mode and P2P bridging */
3027                                 if (fr->subclass == AST_CONTROL_HOLD) {
3028                                         if (p0_callback)
3029                                                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3030                                         if (p1_callback)
3031                                                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3032                                         p0->bridged = NULL;
3033                                         p1->bridged = NULL;
3034                                         if (vp0) {
3035                                                 vp0->bridged = NULL;
3036                                                 vp1->bridged = NULL;
3037                                         }
3038                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3039                                         /* If we are off hold, then go back to callback mode and P2P bridging */
3040                                         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3041                                         p0->bridged = p1;
3042                                         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3043                                         p1->bridged = p0;
3044                                         if (vp0) {
3045                                                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
3046                                                 vp0->bridged = vp1;
3047                                                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
3048                                                 vp1->bridged = vp0;
3049                                         }
3050                                         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3051                                         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3052                                 }
3053                                 ast_indicate(other, fr->subclass);
3054                                 ast_frfree(fr);
3055                         } else {
3056                                 *fo = fr;
3057                                 *rc = who;
3058                                 if (option_debug)
3059                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3060                                 res = AST_BRIDGE_COMPLETE;
3061                                 break;
3062                         }
3063                 } else {
3064                         /* If this is a DTMF, voice, or video frame write it to the other channel */
3065                         if ((fr->frametype == AST_FRAME_DTMF) ||
3066                             (fr->frametype == AST_FRAME_VOICE) ||
3067                             (fr->frametype == AST_FRAME_VIDEO)) {
3068                                 ast_write(other, fr);
3069                         }
3070                         ast_frfree(fr);
3071                 }
3072                 /* Swap priority */
3073                 cs[2] = cs[0];
3074                 cs[0] = cs[1];
3075                 cs[1] = cs[2];
3076         }
3077
3078         /* If we are totally avoiding the core, then restore our link to it */
3079         if (p0_callback)
3080                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3081         if (p1_callback)
3082                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3083
3084         /* Break out of the direct bridge */
3085         p0->bridged = NULL;
3086         p1->bridged = NULL;
3087         if (vp0) {
3088                 vp0->bridged = NULL;
3089                 vp1->bridged = NULL;
3090         }
3091
3092         return res;
3093 }
3094
3095 /*! \brief Bridge calls. If possible and allowed, initiate
3096         re-invite so the peers exchange media directly outside 
3097         of Asterisk. */
3098 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)
3099 {
3100         struct ast_rtp *p0 = NULL, *p1 = NULL;          /* Audio RTP Channels */
3101         struct ast_rtp *vp0 = NULL, *vp1 = NULL;        /* Video RTP channels */
3102         struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3103         enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
3104         enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
3105         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3106         int codec0 = 0, codec1 = 0;
3107         void *pvt0 = NULL, *pvt1 = NULL;
3108
3109         /* Lock channels */
3110         ast_channel_lock(c0);
3111         while(ast_channel_trylock(c1)) {
3112                 ast_channel_unlock(c0);
3113                 usleep(1);
3114                 ast_channel_lock(c0);
3115         }
3116
3117         /* Find channel driver interfaces */
3118         if (!(pr0 = get_proto(c0))) {
3119                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3120                 ast_channel_unlock(c0);
3121                 ast_channel_unlock(c1);
3122                 return AST_BRIDGE_FAILED;
3123         }
3124         if (!(pr1 = get_proto(c1))) {
3125                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3126                 ast_channel_unlock(c0);
3127                 ast_channel_unlock(c1);
3128                 return AST_BRIDGE_FAILED;
3129         }
3130
3131         /* Get channel specific interface structures */
3132         pvt0 = c0->tech_pvt;
3133         pvt1 = c1->tech_pvt;
3134
3135         /* Get audio and video interface (if native bridge is possible) */
3136         audio_p0_res = pr0->get_rtp_info(c0, &p0);
3137         video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3138         audio_p1_res = pr1->get_rtp_info(c1, &p1);
3139         video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3140
3141         /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3142         if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3143                 audio_p0_res = AST_RTP_GET_FAILED;
3144         if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3145                 audio_p1_res = AST_RTP_GET_FAILED;
3146
3147         /* Check if a bridge is possible (partial/native) */
3148         if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3149                 /* Somebody doesn't want to play... */
3150                 ast_channel_unlock(c0);
3151                 ast_channel_unlock(c1);
3152                 return AST_BRIDGE_FAILED_NOWARN;
3153         }
3154
3155         /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3156         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3157                 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3158                 audio_p0_res = AST_RTP_TRY_PARTIAL;
3159         }
3160
3161         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3162                 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3163                 audio_p1_res = AST_RTP_TRY_PARTIAL;
3164         }
3165
3166         /* Get codecs from both sides */
3167         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3168         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3169         if (codec0 && codec1 && !(codec0 & codec1)) {
3170                 /* Hey, we can't do native bridging if both parties speak different codecs */
3171                 if (option_debug)
3172                         ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3173                 ast_channel_unlock(c0);
3174                 ast_channel_unlock(c1);
3175                 return AST_BRIDGE_FAILED_NOWARN;
3176         }
3177
3178         /* If either side can only do a partial bridge, then don't try for a true native bridge */
3179         if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
3180                 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
3181                 if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) {
3182                         if (option_debug)
3183                                 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n");
3184                         ast_channel_unlock(c0);
3185                         ast_channel_unlock(c1);
3186                         return AST_BRIDGE_FAILED_NOWARN;
3187                 }
3188                 if (option_verbose > 2)
3189                         ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
3190                 res = bridge_p2p_loop(c0, c1, p0, p1, vp0, vp1, timeoutms, flags, fo, rc, pvt0, pvt1);
3191         } else {
3192                 if (option_verbose > 2) 
3193                         ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
3194                 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
3195         }
3196
3197         return res;
3198 }
3199
3200 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
3201 {
3202         struct hostent *hp;
3203         struct ast_hostent ahp;
3204         int port = 0;
3205         char *p, *arg;
3206
3207         if (argc != 4)
3208                 return RESULT_SHOWUSAGE;
3209         arg = argv[3];
3210         p = strstr(arg, ":");
3211         if (p) {
3212                 *p = '\0';
3213                 p++;
3214                 port = atoi(p);
3215         }
3216         hp = ast_gethostbyname(arg, &ahp);
3217         if (hp == NULL)
3218                 return RESULT_SHOWUSAGE;
3219         rtpdebugaddr.sin_family = AF_INET;
3220         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
3221         rtpdebugaddr.sin_port = htons(port);
3222         if (port == 0)
3223                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
3224         else
3225                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
3226         rtpdebug = 1;
3227         return RESULT_SUCCESS;
3228 }
3229
3230 static int rtcp_do_debug_ip(int fd, int argc, char *argv[])
3231 {
3232         struct hostent *hp;
3233         struct ast_hostent ahp;
3234         int port = 0;
3235         char *p, *arg;
3236         if (argc != 4)
3237                 return RESULT_SHOWUSAGE;
3238
3239         arg = argv[3];
3240         p = strstr(arg, ":");
3241         if (p) {
3242                 *p = '\0';
3243                 p++;
3244                 port = atoi(p);
3245         }
3246         hp = ast_gethostbyname(arg, &ahp);
3247         if (hp == NULL)
3248                 return RESULT_SHOWUSAGE;
3249         rtcpdebugaddr.sin_family = AF_INET;
3250         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3251         rtcpdebugaddr.sin_port = htons(port);
3252         if (port == 0)
3253                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3254         else
3255                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3256         rtcpdebug = 1;
3257         return RESULT_SUCCESS;
3258 }
3259
3260 static int rtp_do_debug(int fd, int argc, char *argv[])
3261 {
3262         if (argc != 2) {
3263                 if (argc != 4)
3264                         return RESULT_SHOWUSAGE;
3265                 return rtp_do_debug_ip(fd, argc, argv);
3266         }
3267         rtpdebug = 1;
3268         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
3269         ast_cli(fd, "RTP Debugging Enabled\n");
3270         return RESULT_SUCCESS;
3271 }
3272    
3273 static int rtcp_do_debug(int fd, int argc, char *argv[]) {
3274         if (argc != 2) {
3275                 if (argc != 4)
3276                         return RESULT_SHOWUSAGE;
3277                 return rtcp_do_debug_ip(fd, argc, argv);
3278         }
3279         rtcpdebug = 1;
3280         memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3281         ast_cli(fd, "RTCP Debugging Enabled\n");
3282         return RESULT_SUCCESS;
3283 }
3284
3285 static int rtcp_do_stats(int fd, int argc, char *argv[]) {
3286         if (argc != 2) {
3287                 return RESULT_SHOWUSAGE;
3288         }
3289         rtcpstats = 1;
3290         ast_cli(fd, "RTCP Stats Enabled\n");
3291         return RESULT_SUCCESS;
3292 }
3293
3294 static int rtp_no_debug(int fd, int argc, char *argv[])
3295 {
3296         if (argc != 2)
3297                 return RESULT_SHOWUSAGE;
3298         rtpdebug = 0;
3299         ast_cli(fd,"RTP Debugging Disabled\n");
3300         return RESULT_SUCCESS;
3301 }
3302
3303 static int rtcp_no_debug(int fd, int argc, char *argv[])
3304 {
3305         if (argc != 2)
3306                 return RESULT_SHOWUSAGE;
3307         rtcpdebug = 0;
3308         ast_cli(fd,"RTCP Debugging Disabled\n");
3309         return RESULT_SUCCESS;
3310 }
3311
3312 static int rtcp_no_stats(int fd, int argc, char *argv[])
3313 {
3314         if (argc != 2)
3315                 return RESULT_SHOWUSAGE;
3316         rtcpstats = 0;
3317         ast_cli(fd,"RTCP Stats Disabled\n");
3318         return RESULT_SUCCESS;
3319 }
3320
3321 static int stun_do_debug(int fd, int argc, char *argv[])
3322 {
3323         if (argc != 2) {
3324                 return RESULT_SHOWUSAGE;
3325         }
3326         stundebug = 1;
3327         ast_cli(fd, "STUN Debugging Enabled\n");
3328         return RESULT_SUCCESS;
3329 }
3330    
3331 static int stun_no_debug(int fd, int argc, char *argv[])
3332 {
3333         if (argc != 2)
3334                 return RESULT_SHOWUSAGE;
3335         stundebug = 0;
3336         ast_cli(fd,"STUN Debugging Disabled\n");
3337         return RESULT_SUCCESS;
3338 }
3339
3340 static char debug_usage[] =
3341   "Usage: rtp debug [ip host[:port]]\n"
3342   "       Enable dumping of all RTP packets to and from host.\n";
3343
3344 static char no_debug_usage[] =
3345   "Usage: rtp nodebug\n"
3346   "       Disable all RTP debugging\n";
3347
3348 static char stun_debug_usage[] =
3349   "Usage: stun debug\n"
3350   "       Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3351
3352 static char stun_no_debug_usage[] =
3353   "Usage: stun nodebug\n"
3354   "       Disable STUN debugging\n";
3355
3356 static char rtcp_debug_usage[] =
3357   "Usage: rtcp debug [ip host[:port]]\n"
3358   "       Enable dumping of all RTCP packets to and from host.\n";
3359   
3360 static char rtcp_no_debug_usage[] =
3361   "Usage: rtcp nodebug\n"
3362   "       Disable all RTCP debugging\n";
3363
3364 static char rtcp_stats_usage[] =
3365   "Usage: rtcp stats\n"
3366   "       Enable dumping of RTCP stats.\n";
3367   
3368 static char rtcp_no_stats_usage[] =
3369   "Usage: rtcp nostats\n"
3370   "       Disable all RTCP stats\n";
3371
3372 static struct ast_cli_entry cli_rtp[] = {
3373         { { "rtp", "debug", "ip", NULL },
3374         rtp_do_debug, "Enable RTP debugging on IP",
3375         debug_usage },
3376
3377         { { "rtp", "debug", NULL },
3378         rtp_do_debug, "Enable RTP debugging",
3379         debug_usage },
3380
3381         { { "rtp", "nodebug", NULL },
3382         rtp_no_debug, "Disable RTP debugging",
3383         no_debug_usage },
3384
3385         { { "rtcp", "debug", "ip", NULL },
3386         rtcp_do_debug, "Enable RTCP debugging on IP",
3387         rtcp_debug_usage },
3388
3389         { { "rtcp", "debug", NULL },
3390         rtcp_do_debug, "Enable RTCP debugging",
3391         rtcp_debug_usage },
3392
3393         { { "rtcp", "nodebug", NULL },
3394         rtcp_no_debug, "Disable RTCP debugging",
3395         rtcp_no_debug_usage },
3396
3397         { { "rtcp", "stats", NULL },
3398         rtcp_do_stats, "Enable RTCP stats",
3399         rtcp_stats_usage },
3400
3401         { { "rtcp", "nostats", NULL },
3402         rtcp_no_stats, "Disable RTCP stats",
3403         rtcp_no_stats_usage },
3404
3405         { { "stun", "debug", NULL },
3406         stun_do_debug, "Enable STUN debugging",
3407         stun_debug_usage },
3408
3409         { { "stun", "nodebug", NULL },
3410         stun_no_debug, "Disable STUN debugging",
3411         stun_no_debug_usage },
3412 };
3413
3414 int ast_rtp_reload(void)
3415 {
3416         struct ast_config *cfg;
3417         const char *s;
3418
3419         rtpstart = 5000;
3420         rtpend = 31000;
3421         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3422         cfg = ast_config_load("rtp.conf");
3423         if (cfg) {
3424                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
3425                         rtpstart = atoi(s);
3426                         if (rtpstart < 1024)
3427                                 rtpstart = 1024;
3428                         if (rtpstart > 65535)
3429                                 rtpstart = 65535;
3430                 }
3431                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
3432                         rtpend = atoi(s);
3433                         if (rtpend < 1024)
3434                                 rtpend = 1024;
3435                         if (rtpend > 65535)
3436                                 rtpend = 65535;
3437                 }
3438                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
3439                         rtcpinterval = atoi(s);
3440                         if (rtcpinterval == 0)
3441                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
3442                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
3443                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
3444                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
3445                                 rtcpinterval = RTCP_MAX_INTERVALMS;
3446                 }
3447                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
3448 #ifdef SO_NO_CHECK
3449                         if (ast_false(s))
3450                                 nochecksums = 1;
3451                         else
3452                                 nochecksums = 0;
3453 #else
3454                         if (ast_false(s))
3455                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
3456 #endif
3457                 }
3458                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
3459                         dtmftimeout = atoi(s);
3460                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
3461                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3462                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
3463                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3464                         };
3465                 }
3466                 ast_config_destroy(cfg);
3467         }
3468         if (rtpstart >= rtpend) {
3469                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
3470                 rtpstart = 5000;
3471                 rtpend = 31000;
3472         }
3473         if (option_verbose > 1)
3474                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
3475         return 0;
3476 }
3477
3478 /*! \brief Initialize the RTP system in Asterisk */
3479 void ast_rtp_init(void)
3480 {
3481         ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry));
3482         ast_rtp_reload();
3483 }
3484