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