Merged revisions 47639 via svnmerge from
[asterisk/asterisk.git] / main / rtp.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! 
20  * \file 
21  *
22  * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
23  *
24  * \author Mark Spencer <markster@digium.com>
25  * 
26  * \note RTP is defined in RFC 3550.
27  */
28
29 #include "asterisk.h"
30
31 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <sys/time.h>
37 #include <signal.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <netinet/in.h>
41 #include <sys/time.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
44 #include <fcntl.h>
45
46 #include "asterisk/rtp.h"
47 #include "asterisk/frame.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/options.h"
50 #include "asterisk/channel.h"
51 #include "asterisk/acl.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/config.h"
54 #include "asterisk/lock.h"
55 #include "asterisk/utils.h"
56 #include "asterisk/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;
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         /* Bridge media early */
1516         if (destpr->set_rtp_peer(c0, srcp, vsrcp, srccodec, srcp ? ast_test_flag(srcp, FLAG_NAT_ACTIVE) : 0))
1517                 ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1518         ast_channel_unlock(c0);
1519         if (c1)
1520                 ast_channel_unlock(c1);
1521         if (option_debug)
1522                 ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>");
1523         return 0;
1524 }
1525
1526 int ast_rtp_make_compatible(struct ast_channel *dest, struct ast_channel *src, int media)
1527 {
1528         struct ast_rtp *destp = NULL, *srcp = NULL;             /* Audio RTP Channels */
1529         struct ast_rtp *vdestp = NULL, *vsrcp = NULL;           /* Video RTP channels */
1530         struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL;
1531         enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED;
1532         enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; 
1533         int srccodec;
1534
1535         /* Lock channels */
1536         ast_channel_lock(dest);
1537         while(ast_channel_trylock(src)) {
1538                 ast_channel_unlock(dest);
1539                 usleep(1);
1540                 ast_channel_lock(dest);
1541         }
1542
1543         /* Find channel driver interfaces */
1544         if (!(destpr = get_proto(dest))) {
1545                 if (option_debug)
1546                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name);
1547                 ast_channel_unlock(dest);
1548                 ast_channel_unlock(src);
1549                 return 0;
1550         }
1551         if (!(srcpr = get_proto(src))) {
1552                 if (option_debug)
1553                         ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name);
1554                 ast_channel_unlock(dest);
1555                 ast_channel_unlock(src);
1556                 return 0;
1557         }
1558
1559         /* Get audio and video interface (if native bridge is possible) */
1560         audio_dest_res = destpr->get_rtp_info(dest, &destp);
1561         video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED;
1562         audio_src_res = srcpr->get_rtp_info(src, &srcp);
1563         video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED;
1564
1565         /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1566         if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) {
1567                 /* Somebody doesn't want to play... */
1568                 ast_channel_unlock(dest);
1569                 ast_channel_unlock(src);
1570                 return 0;
1571         }
1572         ast_rtp_pt_copy(destp, srcp);
1573         if (vdestp && vsrcp)
1574                 ast_rtp_pt_copy(vdestp, vsrcp);
1575         if (srcpr->get_codec)
1576                 srccodec = srcpr->get_codec(src);
1577         else
1578                 srccodec = 0;
1579         if (media) {
1580                 /* Bridge early */
1581                 if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE)))
1582                         ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name);
1583         }
1584         ast_channel_unlock(dest);
1585         ast_channel_unlock(src);
1586         if (option_debug)
1587                 ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name);
1588         return 1;
1589 }
1590
1591 /*! \brief  Make a note of a RTP payload type that was seen in a SDP "m=" line.
1592  * By default, use the well-known value for this type (although it may 
1593  * still be set to a different value by a subsequent "a=rtpmap:" line)
1594  */
1595 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) 
1596 {
1597         if (pt < 0 || pt > MAX_RTP_PT) 
1598                 return; /* bogus payload type */
1599
1600         if (static_RTP_PT[pt].code != 0) 
1601                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
1602
1603
1604 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1605  * an SDP "a=rtpmap:" line.
1606  */
1607 void ast_rtp_set_rtpmap_type(struct ast_rtp *rtp, int pt,
1608                              char *mimeType, char *mimeSubtype,
1609                              enum ast_rtp_options options)
1610 {
1611         unsigned int i;
1612
1613         if (pt < 0 || pt > MAX_RTP_PT) 
1614                 return; /* bogus payload type */
1615
1616         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1617                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
1618                     strcasecmp(mimeType, mimeTypes[i].type) == 0) {
1619                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
1620                         if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) &&
1621                             mimeTypes[i].payloadType.isAstFormat &&
1622                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1623                                 rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2;
1624                         return;
1625                 }
1626         }
1627
1628
1629 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls 
1630  * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1631 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
1632                              int* astFormats, int* nonAstFormats) {
1633         int pt;
1634
1635         *astFormats = *nonAstFormats = 0;
1636         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1637                 if (rtp->current_RTP_PT[pt].isAstFormat) {
1638                         *astFormats |= rtp->current_RTP_PT[pt].code;
1639                 } else {
1640                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
1641                 }
1642         }
1643 }
1644
1645 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt) 
1646 {
1647         struct rtpPayloadType result;
1648
1649         result.isAstFormat = result.code = 0;
1650         if (pt < 0 || pt > MAX_RTP_PT) 
1651                 return result; /* bogus payload type */
1652
1653         /* Start with negotiated codecs */
1654         result = rtp->current_RTP_PT[pt];
1655
1656         /* If it doesn't exist, check our static RTP type list, just in case */
1657         if (!result.code) 
1658                 result = static_RTP_PT[pt];
1659         return result;
1660 }
1661
1662 /*! \brief Looks up an RTP code out of our *static* outbound list */
1663 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
1664
1665         int pt;
1666
1667         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
1668                 code == rtp->rtp_lookup_code_cache_code) {
1669
1670                 /* Use our cached mapping, to avoid the overhead of the loop below */
1671                 return rtp->rtp_lookup_code_cache_result;
1672         }
1673
1674         /* Check the dynamic list first */
1675         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1676                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
1677                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1678                         rtp->rtp_lookup_code_cache_code = code;
1679                         rtp->rtp_lookup_code_cache_result = pt;
1680                         return pt;
1681                 }
1682         }
1683
1684         /* Then the static list */
1685         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
1686                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
1687                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
1688                         rtp->rtp_lookup_code_cache_code = code;
1689                         rtp->rtp_lookup_code_cache_result = pt;
1690                         return pt;
1691                 }
1692         }
1693         return -1;
1694 }
1695
1696 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code,
1697                                   enum ast_rtp_options options)
1698 {
1699         unsigned int i;
1700
1701         for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) {
1702                 if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) {
1703                         if (isAstFormat &&
1704                             (code == AST_FORMAT_G726_AAL2) &&
1705                             (options & AST_RTP_OPT_G726_NONSTANDARD))
1706                                 return "AAL2-G726-32";
1707                         else
1708                                 return mimeTypes[i].subtype;
1709                 }
1710         }
1711
1712         return "";
1713 }
1714
1715 char *ast_rtp_lookup_mime_multiple(char *buf, size_t size, const int capability,
1716                                    const int isAstFormat, enum ast_rtp_options options)
1717 {
1718         int format;
1719         unsigned len;
1720         char *end = buf;
1721         char *start = buf;
1722
1723         if (!buf || !size)
1724                 return NULL;
1725
1726         snprintf(end, size, "0x%x (", capability);
1727
1728         len = strlen(end);
1729         end += len;
1730         size -= len;
1731         start = end;
1732
1733         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
1734                 if (capability & format) {
1735                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options);
1736
1737                         snprintf(end, size, "%s|", name);
1738                         len = strlen(end);
1739                         end += len;
1740                         size -= len;
1741                 }
1742         }
1743
1744         if (start == end)
1745                 snprintf(start, size, "nothing)"); 
1746         else if (size > 1)
1747                 *(end -1) = ')';
1748         
1749         return buf;
1750 }
1751
1752 /*! \brief Open RTP or RTCP socket for a session */
1753 static int rtp_socket(void)
1754 {
1755         int s;
1756         long flags;
1757         s = socket(AF_INET, SOCK_DGRAM, 0);
1758         if (s > -1) {
1759                 flags = fcntl(s, F_GETFL);
1760                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
1761 #ifdef SO_NO_CHECK
1762                 if (nochecksums)
1763                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
1764 #endif
1765         }
1766         return s;
1767 }
1768
1769 /*!
1770  * \brief Initialize a new RTCP session.
1771  * 
1772  * \returns The newly initialized RTCP session.
1773  */
1774 static struct ast_rtcp *ast_rtcp_new(void)
1775 {
1776         struct ast_rtcp *rtcp;
1777
1778         if (!(rtcp = ast_calloc(1, sizeof(*rtcp))))
1779                 return NULL;
1780         rtcp->s = rtp_socket();
1781         rtcp->us.sin_family = AF_INET;
1782         rtcp->them.sin_family = AF_INET;
1783
1784         if (rtcp->s < 0) {
1785                 free(rtcp);
1786                 ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno));
1787                 return NULL;
1788         }
1789
1790         return rtcp;
1791 }
1792
1793 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
1794 {
1795         struct ast_rtp *rtp;
1796         int x;
1797         int first;
1798         int startplace;
1799         
1800         if (!(rtp = ast_calloc(1, sizeof(*rtp))))
1801                 return NULL;
1802         rtp->them.sin_family = AF_INET;
1803         rtp->us.sin_family = AF_INET;
1804         rtp->s = rtp_socket();
1805         rtp->ssrc = ast_random();
1806         rtp->seqno = ast_random() & 0xffff;
1807         ast_set_flag(rtp, FLAG_HAS_DTMF);
1808         if (rtp->s < 0) {
1809                 free(rtp);
1810                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
1811                 return NULL;
1812         }
1813         if (sched && rtcpenable) {
1814                 rtp->sched = sched;
1815                 rtp->rtcp = ast_rtcp_new();
1816         }
1817         
1818         /* Select a random port number in the range of possible RTP */
1819         x = (ast_random() % (rtpend-rtpstart)) + rtpstart;
1820         x = x & ~1;
1821         /* Save it for future references. */
1822         startplace = x;
1823         /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1824         for (;;) {
1825                 /* Must be an even port number by RTP spec */
1826                 rtp->us.sin_port = htons(x);
1827                 rtp->us.sin_addr = addr;
1828
1829                 /* If there's rtcp, initialize it as well. */
1830                 if (rtp->rtcp) {
1831                         rtp->rtcp->us.sin_port = htons(x + 1);
1832                         rtp->rtcp->us.sin_addr = addr;
1833                 }
1834                 /* Try to bind it/them. */
1835                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
1836                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
1837                         break;
1838                 if (!first) {
1839                         /* Primary bind succeeded! Gotta recreate it */
1840                         close(rtp->s);
1841                         rtp->s = rtp_socket();
1842                 }
1843                 if (errno != EADDRINUSE) {
1844                         /* We got an error that wasn't expected, abort! */
1845                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
1846                         close(rtp->s);
1847                         if (rtp->rtcp) {
1848                                 close(rtp->rtcp->s);
1849                                 free(rtp->rtcp);
1850                         }
1851                         free(rtp);
1852                         return NULL;
1853                 }
1854                 /* The port was used, increment it (by two). */
1855                 x += 2;
1856                 /* Did we go over the limit ? */
1857                 if (x > rtpend)
1858                         /* then, start from the begingig. */
1859                         x = (rtpstart + 1) & ~1;
1860                 /* Check if we reached the place were we started. */
1861                 if (x == startplace) {
1862                         /* If so, there's no ports available. */
1863                         ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n");
1864                         close(rtp->s);
1865                         if (rtp->rtcp) {
1866                                 close(rtp->rtcp->s);
1867                                 free(rtp->rtcp);
1868                         }
1869                         free(rtp);
1870                         return NULL;
1871                 }
1872         }
1873         rtp->sched = sched;
1874         rtp->io = io;
1875         if (callbackmode) {
1876                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
1877                 ast_set_flag(rtp, FLAG_CALLBACK_MODE);
1878         }
1879         ast_rtp_pt_default(rtp);
1880         return rtp;
1881 }
1882
1883 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
1884 {
1885         struct in_addr ia;
1886
1887         memset(&ia, 0, sizeof(ia));
1888         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
1889 }
1890
1891 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
1892 {
1893         int res;
1894
1895         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) 
1896                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
1897         return res;
1898 }
1899
1900 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1901 {
1902         rtp->them.sin_port = them->sin_port;
1903         rtp->them.sin_addr = them->sin_addr;
1904         if (rtp->rtcp) {
1905                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1906                 rtp->rtcp->them.sin_addr = them->sin_addr;
1907         }
1908         rtp->rxseqno = 0;
1909 }
1910
1911 int ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1912 {
1913         if ((them->sin_family != AF_INET) ||
1914                 (them->sin_port != rtp->them.sin_port) ||
1915                 (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) {
1916                 them->sin_family = AF_INET;
1917                 them->sin_port = rtp->them.sin_port;
1918                 them->sin_addr = rtp->them.sin_addr;
1919                 return 1;
1920         }
1921         return 0;
1922 }
1923
1924 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1925 {
1926         *us = rtp->us;
1927 }
1928
1929 struct ast_rtp *ast_rtp_get_bridged(struct ast_rtp *rtp)
1930 {
1931         return rtp->bridged;
1932 }
1933
1934 void ast_rtp_stop(struct ast_rtp *rtp)
1935 {
1936         if (rtp->rtcp && rtp->rtcp->schedid > 0) {
1937                 ast_sched_del(rtp->sched, rtp->rtcp->schedid);
1938                 rtp->rtcp->schedid = -1;
1939         }
1940
1941         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1942         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1943         if (rtp->rtcp) {
1944                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr));
1945                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port));
1946         }
1947         
1948         ast_clear_flag(rtp, FLAG_P2P_SENT_MARK);
1949 }
1950
1951 void ast_rtp_reset(struct ast_rtp *rtp)
1952 {
1953         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1954         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1955         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1956         rtp->lastts = 0;
1957         rtp->lastdigitts = 0;
1958         rtp->lastrxts = 0;
1959         rtp->lastividtimestamp = 0;
1960         rtp->lastovidtimestamp = 0;
1961         rtp->lasteventseqn = 0;
1962         rtp->lasteventendseqn = 0;
1963         rtp->lasttxformat = 0;
1964         rtp->lastrxformat = 0;
1965         rtp->dtmfcount = 0;
1966         rtp->dtmfduration = 0;
1967         rtp->seqno = 0;
1968         rtp->rxseqno = 0;
1969 }
1970
1971 char *ast_rtp_get_quality(struct ast_rtp *rtp)
1972 {
1973         /*
1974         *ssrc          our ssrc
1975         *themssrc      their ssrc
1976         *lp            lost packets
1977         *rxjitter      our calculated jitter(rx)
1978         *rxcount       no. received packets
1979         *txjitter      reported jitter of the other end
1980         *txcount       transmitted packets
1981         *rlp           remote lost packets
1982         */
1983         
1984         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);
1985         
1986         return rtp->rtcp->quality;
1987 }
1988
1989 void ast_rtp_destroy(struct ast_rtp *rtp)
1990 {
1991         if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) {
1992                 /*Print some info on the call here */
1993                 ast_verbose("  RTP-stats\n");
1994                 ast_verbose("* Our Receiver:\n");
1995                 ast_verbose("  SSRC:             %u\n", rtp->themssrc);
1996                 ast_verbose("  Received packets: %u\n", rtp->rxcount);
1997                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior);
1998                 ast_verbose("  Jitter:           %.4f\n", rtp->rxjitter);
1999                 ast_verbose("  Transit:          %.4f\n", rtp->rxtransit);
2000                 ast_verbose("  RR-count:         %u\n", rtp->rtcp->rr_count);
2001                 ast_verbose("* Our Sender:\n");
2002                 ast_verbose("  SSRC:             %u\n", rtp->ssrc);
2003                 ast_verbose("  Sent packets:     %u\n", rtp->txcount);
2004                 ast_verbose("  Lost packets:     %u\n", rtp->rtcp->reported_lost);
2005                 ast_verbose("  Jitter:           %u\n", rtp->rtcp->reported_jitter);
2006                 ast_verbose("  SR-count:         %u\n", rtp->rtcp->sr_count);
2007                 ast_verbose("  RTT:              %f\n", rtp->rtcp->rtt);
2008         }
2009
2010         if (rtp->smoother)
2011                 ast_smoother_free(rtp->smoother);
2012         if (rtp->ioid)
2013                 ast_io_remove(rtp->io, rtp->ioid);
2014         if (rtp->s > -1)
2015                 close(rtp->s);
2016         if (rtp->rtcp) {
2017                 if (rtp->rtcp->schedid > 0)
2018                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2019                 close(rtp->rtcp->s);
2020                 free(rtp->rtcp);
2021                 rtp->rtcp=NULL;
2022         }
2023         free(rtp);
2024 }
2025
2026 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
2027 {
2028         struct timeval t;
2029         long ms;
2030         if (ast_tvzero(rtp->txcore)) {
2031                 rtp->txcore = ast_tvnow();
2032                 /* Round to 20ms for nice, pretty timestamps */
2033                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
2034         }
2035         /* Use previous txcore if available */
2036         t = (delivery && !ast_tvzero(*delivery)) ? *delivery : ast_tvnow();
2037         ms = ast_tvdiff_ms(t, rtp->txcore);
2038         if (ms < 0)
2039                 ms = 0;
2040         /* Use what we just got for next time */
2041         rtp->txcore = t;
2042         return (unsigned int) ms;
2043 }
2044
2045 /*! \brief Send begin frames for DTMF */
2046 int ast_rtp_senddigit_begin(struct ast_rtp *rtp, char digit)
2047 {
2048         unsigned int *rtpheader;
2049         int hdrlen = 12, res = 0, i = 0, payload = 0;
2050         char data[256];
2051
2052         if ((digit <= '9') && (digit >= '0'))
2053                 digit -= '0';
2054         else if (digit == '*')
2055                 digit = 10;
2056         else if (digit == '#')
2057                 digit = 11;
2058         else if ((digit >= 'A') && (digit <= 'D'))
2059                 digit = digit - 'A' + 12;
2060         else if ((digit >= 'a') && (digit <= 'd'))
2061                 digit = digit - 'a' + 12;
2062         else {
2063                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2064                 return 0;
2065         }
2066
2067         /* If we have no peer, return immediately */    
2068         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2069                 return 0;
2070
2071         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
2072
2073         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2074         rtp->send_duration = 160;
2075         
2076         /* Get a pointer to the header */
2077         rtpheader = (unsigned int *)data;
2078         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno));
2079         rtpheader[1] = htonl(rtp->lastdigitts);
2080         rtpheader[2] = htonl(rtp->ssrc); 
2081
2082         for (i = 0; i < 2; i++) {
2083                 rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2084                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2085                 if (res < 0) 
2086                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2087                                 ast_inet_ntoa(rtp->them.sin_addr),
2088                                 ntohs(rtp->them.sin_port), strerror(errno));
2089                 if (rtp_debug_test_addr(&rtp->them))
2090                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2091                                     ast_inet_ntoa(rtp->them.sin_addr),
2092                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2093                 /* Increment sequence number */
2094                 rtp->seqno++;
2095                 /* Increment duration */
2096                 rtp->send_duration += 160;
2097                 /* Clear marker bit and set seqno */
2098                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2099         }
2100
2101         /* Since we received a begin, we can safely store the digit and disable any compensation */
2102         rtp->send_digit = digit;
2103         rtp->send_payload = payload;
2104
2105         return 0;
2106 }
2107
2108 /*! \brief Send continuation frame for DTMF */
2109 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2110 {
2111         unsigned int *rtpheader;
2112         int hdrlen = 12, res = 0;
2113         char data[256];
2114
2115         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2116                 return 0;
2117
2118         /* Setup packet to send */
2119         rtpheader = (unsigned int *)data;
2120         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2121         rtpheader[1] = htonl(rtp->lastdigitts);
2122         rtpheader[2] = htonl(rtp->ssrc);
2123         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration));
2124         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2125         
2126         /* Transmit */
2127         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2128         if (res < 0)
2129                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2130                         ast_inet_ntoa(rtp->them.sin_addr),
2131                         ntohs(rtp->them.sin_port), strerror(errno));
2132         if (rtp_debug_test_addr(&rtp->them))
2133                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2134                             ast_inet_ntoa(rtp->them.sin_addr),
2135                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2136
2137         /* Increment sequence number */
2138         rtp->seqno++;
2139         /* Increment duration */
2140         rtp->send_duration += 160;
2141
2142         return 0;
2143 }
2144
2145 /*! \brief Send end packets for DTMF */
2146 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2147 {
2148         unsigned int *rtpheader;
2149         int hdrlen = 12, res = 0, i = 0;
2150         char data[256];
2151         
2152         /* If no address, then bail out */
2153         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2154                 return 0;
2155         
2156         if ((digit <= '9') && (digit >= '0'))
2157                 digit -= '0';
2158         else if (digit == '*')
2159                 digit = 10;
2160         else if (digit == '#')
2161                 digit = 11;
2162         else if ((digit >= 'A') && (digit <= 'D'))
2163                 digit = digit - 'A' + 12;
2164         else if ((digit >= 'a') && (digit <= 'd'))
2165                 digit = digit - 'a' + 12;
2166         else {
2167                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2168                 return 0;
2169         }
2170
2171         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2172
2173         rtpheader = (unsigned int *)data;
2174         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2175         rtpheader[1] = htonl(rtp->lastdigitts);
2176         rtpheader[2] = htonl(rtp->ssrc);
2177         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration));
2178         /* Set end bit */
2179         rtpheader[3] |= htonl((1 << 23));
2180         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2181         /* Send 3 termination packets */
2182         for (i = 0; i < 3; i++) {
2183                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2184                 if (res < 0)
2185                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2186                                 ast_inet_ntoa(rtp->them.sin_addr),
2187                                 ntohs(rtp->them.sin_port), strerror(errno));
2188                 if (rtp_debug_test_addr(&rtp->them))
2189                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2190                                     ast_inet_ntoa(rtp->them.sin_addr),
2191                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2192         }
2193         rtp->send_digit = 0;
2194         /* Increment lastdigitts */
2195         rtp->lastdigitts += 960;
2196         rtp->seqno++;
2197
2198         return res;
2199 }
2200
2201 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2202 int ast_rtcp_send_h261fur(void *data)
2203 {
2204         struct ast_rtp *rtp = data;
2205         int res;
2206
2207         rtp->rtcp->sendfur = 1;
2208         res = ast_rtcp_write(data);
2209         
2210         return res;
2211 }
2212
2213 /*! \brief Send RTCP sender's report */
2214 static int ast_rtcp_write_sr(void *data)
2215 {
2216         struct ast_rtp *rtp = data;
2217         int res;
2218         int len = 0;
2219         struct timeval now;
2220         unsigned int now_lsw;
2221         unsigned int now_msw;
2222         unsigned int *rtcpheader;
2223         unsigned int lost;
2224         unsigned int extended;
2225         unsigned int expected;
2226         unsigned int expected_interval;
2227         unsigned int received_interval;
2228         int lost_interval;
2229         int fraction;
2230         struct timeval dlsr;
2231         char bdata[512];
2232
2233         /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2234         if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2235                 return 0;
2236         
2237         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2238                 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2239                 if (rtp->rtcp->schedid > 0)
2240                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2241                 rtp->rtcp->schedid = -1;
2242                 return 0;
2243         }
2244
2245         gettimeofday(&now, NULL);
2246         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2247         rtcpheader = (unsigned int *)bdata;
2248         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2249         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2250         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2251         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2252         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2253         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2254         len += 28;
2255         
2256         extended = rtp->cycles + rtp->lastrxseqno;
2257         expected = extended - rtp->seedrxseqno + 1;
2258         if (rtp->rxcount > expected) 
2259                 expected += rtp->rxcount - expected;
2260         lost = expected - rtp->rxcount;
2261         expected_interval = expected - rtp->rtcp->expected_prior;
2262         rtp->rtcp->expected_prior = expected;
2263         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2264         rtp->rtcp->received_prior = rtp->rxcount;
2265         lost_interval = expected_interval - received_interval;
2266         if (expected_interval == 0 || lost_interval <= 0)
2267                 fraction = 0;
2268         else
2269                 fraction = (lost_interval << 8) / expected_interval;
2270         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2271         rtcpheader[7] = htonl(rtp->themssrc);
2272         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2273         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2274         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2275         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2276         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2277         len += 24;
2278         
2279         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2280
2281         if (rtp->rtcp->sendfur) {
2282                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2283                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2284                 len += 8;
2285                 rtp->rtcp->sendfur = 0;
2286         }
2287         
2288         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2289         /* it can change mid call, and SDES can't) */
2290         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2291         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2292         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2293         len += 12;
2294         
2295         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2296         if (res < 0) {
2297                 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));
2298                 if (rtp->rtcp->schedid > 0)
2299                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2300                 rtp->rtcp->schedid = -1;
2301                 return 0;
2302         }
2303         
2304         /* FIXME Don't need to get a new one */
2305         gettimeofday(&rtp->rtcp->txlsr, NULL);
2306         rtp->rtcp->sr_count++;
2307
2308         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2309         
2310         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2311                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2312                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2313                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2314                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2315                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2316                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2317                 ast_verbose("  Report block:\n");
2318                 ast_verbose("  Fraction lost: %u\n", fraction);
2319                 ast_verbose("  Cumulative loss: %u\n", lost);
2320                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2321                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2322                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2323         }
2324         return res;
2325 }
2326
2327 /*! \brief Send RTCP recipient's report */
2328 static int ast_rtcp_write_rr(void *data)
2329 {
2330         struct ast_rtp *rtp = data;
2331         int res;
2332         int len = 32;
2333         unsigned int lost;
2334         unsigned int extended;
2335         unsigned int expected;
2336         unsigned int expected_interval;
2337         unsigned int received_interval;
2338         int lost_interval;
2339         struct timeval now;
2340         unsigned int *rtcpheader;
2341         char bdata[1024];
2342         struct timeval dlsr;
2343         int fraction;
2344
2345         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2346                 return 0;
2347           
2348         if (!rtp->rtcp->them.sin_addr.s_addr) {
2349                 ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno));
2350                 if (rtp->rtcp->schedid > 0)
2351                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2352                 rtp->rtcp->schedid = -1;
2353                 return 0;
2354         }
2355
2356         extended = rtp->cycles + rtp->lastrxseqno;
2357         expected = extended - rtp->seedrxseqno + 1;
2358         lost = expected - rtp->rxcount;
2359         expected_interval = expected - rtp->rtcp->expected_prior;
2360         rtp->rtcp->expected_prior = expected;
2361         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2362         rtp->rtcp->received_prior = rtp->rxcount;
2363         lost_interval = expected_interval - received_interval;
2364         if (expected_interval == 0 || lost_interval <= 0)
2365                 fraction = 0;
2366         else
2367                 fraction = (lost_interval << 8) / expected_interval;
2368         gettimeofday(&now, NULL);
2369         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2370         rtcpheader = (unsigned int *)bdata;
2371         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2372         rtcpheader[1] = htonl(rtp->ssrc);
2373         rtcpheader[2] = htonl(rtp->themssrc);
2374         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2375         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2376         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2377         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2378         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2379
2380         if (rtp->rtcp->sendfur) {
2381                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2382                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2383                 len += 8;
2384                 rtp->rtcp->sendfur = 0;
2385         }
2386
2387         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2388         it can change mid call, and SDES can't) */
2389         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2390         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2391         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2392         len += 12;
2393         
2394         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2395
2396         if (res < 0) {
2397                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2398                 /* Remove the scheduler */
2399                 if (rtp->rtcp->schedid > 0)
2400                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2401                 rtp->rtcp->schedid = -1;
2402                 return 0;
2403         }
2404
2405         rtp->rtcp->rr_count++;
2406
2407         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2408                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2409                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2410                         "  IA jitter: %.4f\n" 
2411                         "  Their last SR: %u\n" 
2412                         "  DLSR: %4.4f (sec)\n\n",
2413                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2414                         ntohs(rtp->rtcp->them.sin_port),
2415                         rtp->ssrc, rtp->themssrc, fraction, lost,
2416                         rtp->rxjitter,
2417                         rtp->rtcp->themrxlsr,
2418                         (double)(ntohl(rtcpheader[7])/65536.0));
2419         }
2420
2421         return res;
2422 }
2423
2424 /*! \brief Write and RTCP packet to the far end
2425  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2426  * RR is sent if we have not sent any rtp packets in the previous interval */
2427 static int ast_rtcp_write(void *data)
2428 {
2429         struct ast_rtp *rtp = data;
2430         int res;
2431         
2432         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2433                 res = ast_rtcp_write_sr(data);
2434         else
2435                 res = ast_rtcp_write_rr(data);
2436         
2437         return res;
2438 }
2439
2440 /*! \brief generate comfort noice (CNG) */
2441 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2442 {
2443         unsigned int *rtpheader;
2444         int hdrlen = 12;
2445         int res;
2446         int payload;
2447         char data[256];
2448         level = 127 - (level & 0x7f);
2449         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2450
2451         /* If we have no peer, return immediately */    
2452         if (!rtp->them.sin_addr.s_addr)
2453                 return 0;
2454
2455         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2456
2457         /* Get a pointer to the header */
2458         rtpheader = (unsigned int *)data;
2459         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2460         rtpheader[1] = htonl(rtp->lastts);
2461         rtpheader[2] = htonl(rtp->ssrc); 
2462         data[12] = level;
2463         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2464                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2465                 if (res <0) 
2466                         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));
2467                 if (rtp_debug_test_addr(&rtp->them))
2468                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %u, len %d)\n"
2469                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2470                    
2471         }
2472         return 0;
2473 }
2474
2475 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2476 {
2477         unsigned char *rtpheader;
2478         int hdrlen = 12;
2479         int res;
2480         unsigned int ms;
2481         int pred;
2482         int mark = 0;
2483
2484         ms = calc_txstamp(rtp, &f->delivery);
2485         /* Default prediction */
2486         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2487                 pred = rtp->lastts + f->samples;
2488
2489                 /* Re-calculate last TS */
2490                 rtp->lastts = rtp->lastts + ms * 8;
2491                 if (ast_tvzero(f->delivery)) {
2492                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2493                            and if so, go with our prediction */
2494                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2495                                 rtp->lastts = pred;
2496                         else {
2497                                 if (option_debug > 2)
2498                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2499                                 mark = 1;
2500                         }
2501                 }
2502         } else {
2503                 mark = f->subclass & 0x1;
2504                 pred = rtp->lastovidtimestamp + f->samples;
2505                 /* Re-calculate last TS */
2506                 rtp->lastts = rtp->lastts + ms * 90;
2507                 /* If it's close to our prediction, go for it */
2508                 if (ast_tvzero(f->delivery)) {
2509                         if (abs(rtp->lastts - pred) < 7200) {
2510                                 rtp->lastts = pred;
2511                                 rtp->lastovidtimestamp += f->samples;
2512                         } else {
2513                                 if (option_debug > 2)
2514                                         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);
2515                                 rtp->lastovidtimestamp = rtp->lastts;
2516                         }
2517                 }
2518         }
2519         /* If the timestamp for non-digit packets has moved beyond the timestamp
2520            for digits, update the digit timestamp.
2521         */
2522         if (rtp->lastts > rtp->lastdigitts)
2523                 rtp->lastdigitts = rtp->lastts;
2524
2525         if (f->has_timing_info)
2526                 rtp->lastts = f->ts * 8;
2527
2528         /* Get a pointer to the header */
2529         rtpheader = (unsigned char *)(f->data - hdrlen);
2530
2531         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2532         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2533         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2534
2535         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2536                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2537                 if (res <0) {
2538                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2539                                 if (option_debug)
2540                                         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));
2541                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2542                                 /* Only give this error message once if we are not RTP debugging */
2543                                 if (option_debug || rtpdebug)
2544                                         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));
2545                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2546                         }
2547                 } else {
2548                         rtp->txcount++;
2549                         rtp->txoctetcount +=(res - hdrlen);
2550                         
2551                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2552                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2553                 }
2554                                 
2555                 if (rtp_debug_test_addr(&rtp->them))
2556                         ast_verbose("Sent RTP packet to      %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2557                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2558         }
2559
2560         rtp->seqno++;
2561
2562         return 0;
2563 }
2564
2565 int ast_rtp_codec_setpref(struct ast_rtp *rtp, struct ast_codec_pref *prefs)
2566 {
2567         int x;
2568         for (x = 0; x < 32; x++) {  /* Ugly way */
2569                 rtp->pref.order[x] = prefs->order[x];
2570                 rtp->pref.framing[x] = prefs->framing[x];
2571         }
2572         if (rtp->smoother)
2573                 ast_smoother_free(rtp->smoother);
2574         rtp->smoother = NULL;
2575         return 0;
2576 }
2577
2578 struct ast_codec_pref *ast_rtp_codec_getpref(struct ast_rtp *rtp)
2579 {
2580         return &rtp->pref;
2581 }
2582
2583 int ast_rtp_codec_getformat(int pt)
2584 {
2585         if (pt < 0 || pt > MAX_RTP_PT)
2586                 return 0; /* bogus payload type */
2587
2588         if (static_RTP_PT[pt].isAstFormat)
2589                 return static_RTP_PT[pt].code;
2590         else
2591                 return 0;
2592 }
2593
2594 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2595 {
2596         struct ast_frame *f;
2597         int codec;
2598         int hdrlen = 12;
2599         int subclass;
2600         
2601
2602         /* If we have no peer, return immediately */    
2603         if (!rtp->them.sin_addr.s_addr)
2604                 return 0;
2605
2606         /* If there is no data length, return immediately */
2607         if (!_f->datalen) 
2608                 return 0;
2609         
2610         /* Make sure we have enough space for RTP header */
2611         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2612                 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2613                 return -1;
2614         }
2615
2616         subclass = _f->subclass;
2617         if (_f->frametype == AST_FRAME_VIDEO)
2618                 subclass &= ~0x1;
2619
2620         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2621         if (codec < 0) {
2622                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2623                 return -1;
2624         }
2625
2626         if (rtp->lasttxformat != subclass) {
2627                 /* New format, reset the smoother */
2628                 if (option_debug)
2629                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2630                 rtp->lasttxformat = subclass;
2631                 if (rtp->smoother)
2632                         ast_smoother_free(rtp->smoother);
2633                 rtp->smoother = NULL;
2634         }
2635
2636         if (!rtp->smoother) {
2637                 struct ast_format_list fmt = ast_codec_pref_getsize(&rtp->pref, subclass);
2638                 if (fmt.inc_ms) { /* if codec parameters is set / avoid division by zero */
2639                         if (!(rtp->smoother = ast_smoother_new((fmt.cur_ms * fmt.fr_len) / fmt.inc_ms))) {
2640                                 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));
2641                                 return -1;
2642                         }
2643                         if (fmt.flags)
2644                                 ast_smoother_set_flags(rtp->smoother, fmt.flags);
2645                         if (option_debug)
2646                                 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));
2647                 }
2648         }
2649         if (rtp->smoother) {
2650                 if (ast_smoother_test_flag(rtp->smoother, AST_SMOOTHER_FLAG_BE)) {
2651                         ast_smoother_feed_be(rtp->smoother, _f);
2652                 } else {
2653                         ast_smoother_feed(rtp->smoother, _f);
2654                 }
2655
2656                 while((f = ast_smoother_read(rtp->smoother)))
2657                         ast_rtp_raw_write(rtp, f, codec);
2658         } else {
2659                 /* Don't buffer outgoing frames; send them one-per-packet: */
2660                 if (_f->offset < hdrlen) {
2661                         f = ast_frdup(_f);
2662                 } else {
2663                         f = _f;
2664                 }
2665                 ast_rtp_raw_write(rtp, f, codec);
2666         }
2667                 
2668         return 0;
2669 }
2670
2671 /*! \brief Unregister interface to channel driver */
2672 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2673 {
2674         AST_LIST_LOCK(&protos);
2675         AST_LIST_REMOVE(&protos, proto, list);
2676         AST_LIST_UNLOCK(&protos);
2677 }
2678
2679 /*! \brief Register interface to channel driver */
2680 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2681 {
2682         struct ast_rtp_protocol *cur;
2683
2684         AST_LIST_LOCK(&protos);
2685         AST_LIST_TRAVERSE(&protos, cur, list) { 
2686                 if (!strcmp(cur->type, proto->type)) {
2687                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2688                         AST_LIST_UNLOCK(&protos);
2689                         return -1;
2690                 }
2691         }
2692         AST_LIST_INSERT_HEAD(&protos, proto, list);
2693         AST_LIST_UNLOCK(&protos);
2694         
2695         return 0;
2696 }
2697
2698 /*! \brief Bridge loop for true native bridge (reinvite) */
2699 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)
2700 {
2701         struct ast_frame *fr = NULL;
2702         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2703         int oldcodec0 = codec0, oldcodec1 = codec1;
2704         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2705         struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2706
2707         /* Set it up so audio goes directly between the two endpoints */
2708
2709         /* Test the first channel */
2710         if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2711                 ast_rtp_get_peer(p1, &ac1);
2712                 if (vp1)
2713                         ast_rtp_get_peer(vp1, &vac1);
2714         } else
2715                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2716         
2717         /* Test the second channel */
2718         if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2719                 ast_rtp_get_peer(p0, &ac0);
2720                 if (vp0)
2721                         ast_rtp_get_peer(vp0, &vac0);
2722         } else
2723                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2724
2725         /* Now we can unlock and move into our loop */
2726         ast_channel_unlock(c0);
2727         ast_channel_unlock(c1);
2728
2729         /* Throw our channels into the structure and enter the loop */
2730         cs[0] = c0;
2731         cs[1] = c1;
2732         cs[2] = NULL;
2733         for (;;) {
2734                 /* Check if anything changed */
2735                 if ((c0->tech_pvt != pvt0) ||
2736                     (c1->tech_pvt != pvt1) ||
2737                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2738                         if (option_debug)
2739                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2740                         if (c0->tech_pvt == pvt0)
2741                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2742                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2743                         if (c1->tech_pvt == pvt1)
2744                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2745                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2746                         return AST_BRIDGE_RETRY;
2747                 }
2748
2749                 /* Check if they have changed their address */
2750                 ast_rtp_get_peer(p1, &t1);
2751                 if (vp1)
2752                         ast_rtp_get_peer(vp1, &vt1);
2753                 if (pr1->get_codec)
2754                         codec1 = pr1->get_codec(c1);
2755                 ast_rtp_get_peer(p0, &t0);
2756                 if (vp0)
2757                         ast_rtp_get_peer(vp0, &vt0);
2758                 if (pr0->get_codec)
2759                         codec0 = pr0->get_codec(c0);
2760                 if ((inaddrcmp(&t1, &ac1)) ||
2761                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2762                     (codec1 != oldcodec1)) {
2763                         if (option_debug > 1) {
2764                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2765                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2766                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2767                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2768                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2769                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2770                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2771                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2772                         }
2773                         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)))
2774                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2775                         memcpy(&ac1, &t1, sizeof(ac1));
2776                         memcpy(&vac1, &vt1, sizeof(vac1));
2777                         oldcodec1 = codec1;
2778                 }
2779                 if ((inaddrcmp(&t0, &ac0)) ||
2780                     (vp0 && inaddrcmp(&vt0, &vac0))) {
2781                         if (option_debug > 1) {
2782                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2783                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2784                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2785                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2786                         }
2787                         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)))
2788                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2789                         memcpy(&ac0, &t0, sizeof(ac0));
2790                         memcpy(&vac0, &vt0, sizeof(vac0));
2791                         oldcodec0 = codec0;
2792                 }
2793
2794                 /* Wait for frame to come in on the channels */
2795                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2796                         if (!timeoutms)
2797                                 return AST_BRIDGE_RETRY;
2798                         if (option_debug)
2799                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2800                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2801                                 break;
2802                         continue;
2803                 }
2804                 fr = ast_read(who);
2805                 other = (who == c0) ? c1 : c0;
2806                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2807                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2808                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2809                         /* Break out of bridge */
2810                         *fo = fr;
2811                         *rc = who;
2812                         if (option_debug)
2813                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2814                         if (c0->tech_pvt == pvt0)
2815                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2816                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2817                         if (c1->tech_pvt == pvt1)
2818                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2819                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2820                         return AST_BRIDGE_COMPLETE;
2821                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2822                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2823                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2824                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2825                                 ast_indicate(other, fr->subclass);
2826                                 ast_frfree(fr);
2827                         } else {
2828                                 *fo = fr;
2829                                 *rc = who;
2830                                 if (option_debug)
2831                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2832                                 return AST_BRIDGE_COMPLETE;
2833                         }
2834                 } else {
2835                         if ((fr->frametype == AST_FRAME_DTMF) ||
2836                             (fr->frametype == AST_FRAME_VOICE) ||
2837                             (fr->frametype == AST_FRAME_VIDEO)) {
2838                                 ast_write(other, fr);
2839                         }
2840                         ast_frfree(fr);
2841                 }
2842                 /* Swap priority */
2843                 cs[2] = cs[0];
2844                 cs[0] = cs[1];
2845                 cs[1] = cs[2];
2846         }
2847
2848         return AST_BRIDGE_FAILED;
2849 }
2850
2851 /*! \brief P2P RTP/RTCP Callback */
2852 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
2853 {
2854         int res = 0, hdrlen = 12;
2855         struct sockaddr_in sin;
2856         socklen_t len;
2857         unsigned int *header;
2858         struct ast_rtp *rtp = cbdata;
2859         int is_rtp = 0, is_rtcp = 0;
2860
2861         if (!rtp)
2862                 return 1;
2863
2864         len = sizeof(sin);
2865         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
2866                 return 1;
2867
2868         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
2869
2870         /* Determine what this file descriptor is for */
2871         if (rtp->s == fd)
2872                 is_rtp = 1;
2873         else if (rtp->rtcp && rtp->rtcp->s == fd)
2874                 is_rtcp = 1;
2875
2876         /* If NAT support is turned on, then see if we need to change their address */
2877         if (rtp->nat) {
2878                 /* If this is for RTP, check that - if it's for RTCP, check that */
2879                 if (is_rtp) {
2880                         if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2881                             (rtp->them.sin_port != sin.sin_port)) {
2882                                 rtp->them = sin;
2883                                 rtp->rxseqno = 0;
2884                                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2885                                 if (option_debug || rtpdebug)
2886                                         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));
2887                         }
2888                 } else if (is_rtcp) {
2889                         if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2890                             (rtp->rtcp->them.sin_port != sin.sin_port)) {
2891                                 rtp->rtcp->them = sin;
2892                                 if (option_debug || rtpdebug)
2893                                         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));
2894                         }
2895                 }
2896         }
2897
2898         /* If this came from the RTP stream, write out via RTP - if it's RTCP, write out via RTCP */
2899         if (ast_rtp_get_bridged(rtp)) {
2900                 if (is_rtp)
2901                         bridge_p2p_rtp_write(rtp, header, res, hdrlen);
2902                 else if (is_rtcp)
2903                         bridge_p2p_rtcp_write(rtp, header, res);
2904         }
2905
2906         return 1;
2907 }
2908
2909 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
2910 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2911 {
2912         /* If we need DTMF or we have no IO structure, then we can't do direct callback */
2913         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || !rtp->io)
2914                 return 0;
2915
2916         /* If the RTP structure is already in callback mode, remove it temporarily */
2917         if (rtp->ioid) {
2918                 ast_io_remove(rtp->io, rtp->ioid);
2919                 rtp->ioid = NULL;
2920         }
2921
2922         /* Steal the file descriptors from the channel and stash them away */
2923         fds[0] = chan->fds[0];
2924         fds[1] = chan->fds[1];
2925         chan->fds[0] = -1;
2926         chan->fds[1] = -1;
2927
2928         /* Now, fire up callback mode */
2929         iod[0] = ast_io_add(rtp->io, fds[0], p2p_rtp_callback, AST_IO_IN, rtp);
2930         if (fds[1] >= 0)
2931                 iod[1] = ast_io_add(rtp->io, fds[1], p2p_rtp_callback, AST_IO_IN, rtp);
2932
2933         return 1;
2934 }
2935
2936 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
2937 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2938 {
2939         ast_channel_lock(chan);
2940         /* Remove the callback from the IO context */
2941         ast_io_remove(rtp->io, iod[0]);
2942         ast_io_remove(rtp->io, iod[1]);
2943         /* Restore file descriptors */
2944         chan->fds[0] = fds[0];
2945         chan->fds[1] = fds[1];
2946         ast_channel_unlock(chan);
2947         /* Restore callback mode if previously used */
2948         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
2949             rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2950         return 0;
2951 }
2952
2953 /*! \brief Bridge loop for partial native bridge (packet2packet) */
2954 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)
2955 {
2956         struct ast_frame *fr = NULL;
2957         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2958         int p0_fds[2] = {-1, -1}, p1_fds[2] = {-1, -1};
2959         int *p0_iod[2] = {NULL, }, *p1_iod[2] = {NULL, };
2960         int p0_callback = 0, p1_callback = 0;
2961         enum ast_bridge_result res = AST_BRIDGE_FAILED;
2962
2963         /* Okay, setup each RTP structure to do P2P forwarding */
2964         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
2965         p0->bridged = p1;
2966         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
2967         p1->bridged = p0;
2968         if (vp0) {
2969                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
2970                 vp0->bridged = vp1;
2971                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
2972                 vp1->bridged = vp0;
2973         }
2974
2975         /* Activate callback modes if possible */
2976         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
2977         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
2978
2979         /* Now let go of the channel locks and be on our way */
2980         ast_channel_unlock(c0);
2981         ast_channel_unlock(c1);
2982
2983         /* Go into a loop forwarding frames until we don't need to anymore */
2984         cs[0] = c0;
2985         cs[1] = c1;
2986         cs[2] = NULL;
2987         for (;;) {
2988                 /* Check if anything changed */
2989                 if ((c0->tech_pvt != pvt0) ||
2990                     (c1->tech_pvt != pvt1) ||
2991                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2992                         if (option_debug)
2993                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2994                         res = AST_BRIDGE_RETRY;
2995                         break;
2996                 }
2997                 /* Wait on a channel to feed us a frame */
2998                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2999                         if (!timeoutms) {
3000                                 res = AST_BRIDGE_RETRY;
3001                                 break;
3002                         }
3003                         if (option_debug)
3004                                 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
3005                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
3006                                 break;
3007                         continue;
3008                 }
3009                 /* Read in frame from channel */
3010                 fr = ast_read(who);
3011                 other = (who == c0) ? c1 : c0;
3012                 /* Dependong on the frame we may need to break out of our bridge */
3013                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
3014                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
3015                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
3016                         /* Record received frame and who */
3017                         *fo = fr;
3018                         *rc = who;
3019                         if (option_debug)
3020                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
3021                         res = AST_BRIDGE_COMPLETE;
3022                         break;
3023                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3024                         if ((fr->subclass == AST_CONTROL_HOLD) ||
3025                             (fr->subclass == AST_CONTROL_UNHOLD) ||
3026                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
3027                                 /* If we are going on hold, then break callback mode and P2P bridging */
3028                                 if (fr->subclass == AST_CONTROL_HOLD) {
3029                                         if (p0_callback)
3030                                                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3031                                         if (p1_callback)
3032                                                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3033                                         p0->bridged = NULL;
3034                                         p1->bridged = NULL;
3035                                         if (vp0) {
3036                                                 vp0->bridged = NULL;
3037                                                 vp1->bridged = NULL;
3038                                         }
3039                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
3040                                         /* If we are off hold, then go back to callback mode and P2P bridging */
3041                                         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
3042                                         p0->bridged = p1;
3043                                         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
3044                                         p1->bridged = p0;
3045                                         if (vp0) {
3046                                                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
3047                                                 vp0->bridged = vp1;
3048                                                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
3049                                                 vp1->bridged = vp0;
3050                                         }
3051                                         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
3052                                         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
3053                                 }
3054                                 ast_indicate(other, fr->subclass);
3055                                 ast_frfree(fr);
3056                         } else {
3057                                 *fo = fr;
3058                                 *rc = who;
3059                                 if (option_debug)
3060                                         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3061                                 res = AST_BRIDGE_COMPLETE;
3062                                 break;
3063                         }
3064                 } else {
3065                         /* If this is a DTMF, voice, or video frame write it to the other channel */
3066                         if ((fr->frametype == AST_FRAME_DTMF) ||
3067                             (fr->frametype == AST_FRAME_VOICE) ||
3068                             (fr->frametype == AST_FRAME_VIDEO)) {
3069                                 ast_write(other, fr);
3070                         }
3071                         ast_frfree(fr);
3072                 }
3073                 /* Swap priority */
3074                 cs[2] = cs[0];
3075                 cs[0] = cs[1];
3076                 cs[1] = cs[2];
3077         }
3078
3079         /* If we are totally avoiding the core, then restore our link to it */
3080         if (p0_callback)
3081                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3082         if (p1_callback)
3083                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3084
3085         /* Break out of the direct bridge */
3086         p0->bridged = NULL;
3087         p1->bridged = NULL;
3088         if (vp0) {
3089                 vp0->bridged = NULL;
3090                 vp1->bridged = NULL;
3091         }
3092
3093         return res;
3094 }
3095
3096 /*! \brief Bridge calls. If possible and allowed, initiate
3097         re-invite so the peers exchange media directly outside 
3098         of Asterisk. */
3099 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)
3100 {
3101         struct ast_rtp *p0 = NULL, *p1 = NULL;          /* Audio RTP Channels */
3102         struct ast_rtp *vp0 = NULL, *vp1 = NULL;        /* Video RTP channels */
3103         struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3104         enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
3105         enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
3106         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3107         int codec0 = 0, codec1 = 0;
3108         void *pvt0 = NULL, *pvt1 = NULL;
3109
3110         /* Lock channels */
3111         ast_channel_lock(c0);
3112         while(ast_channel_trylock(c1)) {
3113                 ast_channel_unlock(c0);
3114                 usleep(1);
3115                 ast_channel_lock(c0);
3116         }
3117
3118         /* Find channel driver interfaces */
3119         if (!(pr0 = get_proto(c0))) {
3120                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3121                 ast_channel_unlock(c0);
3122                 ast_channel_unlock(c1);
3123                 return AST_BRIDGE_FAILED;
3124         }
3125         if (!(pr1 = get_proto(c1))) {
3126                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3127                 ast_channel_unlock(c0);
3128                 ast_channel_unlock(c1);
3129                 return AST_BRIDGE_FAILED;
3130         }
3131
3132         /* Get channel specific interface structures */
3133         pvt0 = c0->tech_pvt;
3134         pvt1 = c1->tech_pvt;
3135
3136         /* Get audio and video interface (if native bridge is possible) */
3137         audio_p0_res = pr0->get_rtp_info(c0, &p0);
3138         video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3139         audio_p1_res = pr1->get_rtp_info(c1, &p1);
3140         video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3141
3142         /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3143         if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3144                 audio_p0_res = AST_RTP_GET_FAILED;
3145         if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3146                 audio_p1_res = AST_RTP_GET_FAILED;
3147
3148         /* Check if a bridge is possible (partial/native) */
3149         if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3150                 /* Somebody doesn't want to play... */
3151                 ast_channel_unlock(c0);
3152                 ast_channel_unlock(c1);
3153                 return AST_BRIDGE_FAILED_NOWARN;
3154         }
3155
3156         /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3157         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3158                 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3159                 audio_p0_res = AST_RTP_TRY_PARTIAL;
3160         }
3161
3162         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3163                 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3164                 audio_p1_res = AST_RTP_TRY_PARTIAL;
3165         }
3166
3167         /* Get codecs from both sides */
3168         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3169         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3170         if (codec0 && codec1 && !(codec0 & codec1)) {
3171                 /* Hey, we can't do native bridging if both parties speak different codecs */
3172                 if (option_debug)
3173                         ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3174                 ast_channel_unlock(c0);
3175                 ast_channel_unlock(c1);
3176                 return AST_BRIDGE_FAILED_NOWARN;
3177         }
3178
3179         /* If either side can only do a partial bridge, then don't try for a true native bridge */
3180         if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
3181                 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
3182                 if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) {
3183                         if (option_debug)
3184                                 ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n");
3185                         ast_channel_unlock(c0);
3186                         ast_channel_unlock(c1);
3187                         return AST_BRIDGE_FAILED_NOWARN;
3188                 }
3189                 if (option_verbose > 2)
3190                         ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
3191                 res = bridge_p2p_loop(c0, c1, p0, p1, vp0, vp1, timeoutms, flags, fo, rc, pvt0, pvt1);
3192         } else {
3193                 if (option_verbose > 2) 
3194                         ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
3195                 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
3196         }
3197
3198         return res;
3199 }
3200
3201 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
3202 {
3203         struct hostent *hp;
3204         struct ast_hostent ahp;
3205         int port = 0;
3206         char *p, *arg;
3207
3208         if (argc != 4)
3209                 return RESULT_SHOWUSAGE;
3210         arg = argv[3];
3211         p = strstr(arg, ":");
3212         if (p) {
3213                 *p = '\0';
3214                 p++;
3215                 port = atoi(p);
3216         }
3217         hp = ast_gethostbyname(arg, &ahp);
3218         if (hp == NULL)
3219                 return RESULT_SHOWUSAGE;
3220         rtpdebugaddr.sin_family = AF_INET;
3221         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
3222         rtpdebugaddr.sin_port = htons(port);
3223         if (port == 0)
3224                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr.sin_addr));
3225         else
3226                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr.sin_addr), port);
3227         rtpdebug = 1;
3228         return RESULT_SUCCESS;
3229 }
3230
3231 static int rtcp_do_debug_ip(int fd, int argc, char *argv[])
3232 {
3233         struct hostent *hp;
3234         struct ast_hostent ahp;
3235         int port = 0;
3236         char *p, *arg;
3237         if (argc != 4)
3238                 return RESULT_SHOWUSAGE;
3239
3240         arg = argv[3];
3241         p = strstr(arg, ":");
3242         if (p) {
3243                 *p = '\0';
3244                 p++;
3245                 port = atoi(p);
3246         }
3247         hp = ast_gethostbyname(arg, &ahp);
3248         if (hp == NULL)
3249                 return RESULT_SHOWUSAGE;
3250         rtcpdebugaddr.sin_family = AF_INET;
3251         memcpy(&rtcpdebugaddr.sin_addr, hp->h_addr, sizeof(rtcpdebugaddr.sin_addr));
3252         rtcpdebugaddr.sin_port = htons(port);
3253         if (port == 0)
3254                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr));
3255         else
3256                 ast_cli(fd, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr.sin_addr), port);
3257         rtcpdebug = 1;
3258         return RESULT_SUCCESS;
3259 }
3260
3261 static int rtp_do_debug(int fd, int argc, char *argv[])
3262 {
3263         if (argc != 2) {
3264                 if (argc != 4)
3265                         return RESULT_SHOWUSAGE;
3266                 return rtp_do_debug_ip(fd, argc, argv);
3267         }
3268         rtpdebug = 1;
3269         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
3270         ast_cli(fd, "RTP Debugging Enabled\n");
3271         return RESULT_SUCCESS;
3272 }
3273    
3274 static int rtcp_do_debug(int fd, int argc, char *argv[]) {
3275         if (argc != 2) {
3276                 if (argc != 4)
3277                         return RESULT_SHOWUSAGE;
3278                 return rtcp_do_debug_ip(fd, argc, argv);
3279         }
3280         rtcpdebug = 1;
3281         memset(&rtcpdebugaddr,0,sizeof(rtcpdebugaddr));
3282         ast_cli(fd, "RTCP Debugging Enabled\n");
3283         return RESULT_SUCCESS;
3284 }
3285
3286 static int rtcp_do_stats(int fd, int argc, char *argv[]) {
3287         if (argc != 2) {
3288                 return RESULT_SHOWUSAGE;
3289         }
3290         rtcpstats = 1;
3291         ast_cli(fd, "RTCP Stats Enabled\n");
3292         return RESULT_SUCCESS;
3293 }
3294
3295 static int rtp_no_debug(int fd, int argc, char *argv[])
3296 {
3297         if (argc != 3)
3298                 return RESULT_SHOWUSAGE;
3299         rtpdebug = 0;
3300         ast_cli(fd,"RTP Debugging Disabled\n");
3301         return RESULT_SUCCESS;
3302 }
3303
3304 static int rtcp_no_debug(int fd, int argc, char *argv[])
3305 {
3306         if (argc != 3)
3307                 return RESULT_SHOWUSAGE;
3308         rtcpdebug = 0;
3309         ast_cli(fd,"RTCP Debugging Disabled\n");
3310         return RESULT_SUCCESS;
3311 }
3312
3313 static int rtcp_no_stats(int fd, int argc, char *argv[])
3314 {
3315         if (argc != 3)
3316                 return RESULT_SHOWUSAGE;
3317         rtcpstats = 0;
3318         ast_cli(fd,"RTCP Stats Disabled\n");
3319         return RESULT_SUCCESS;
3320 }
3321
3322 static int stun_do_debug(int fd, int argc, char *argv[])
3323 {
3324         if (argc != 2) {
3325                 return RESULT_SHOWUSAGE;
3326         }
3327         stundebug = 1;
3328         ast_cli(fd, "STUN Debugging Enabled\n");
3329         return RESULT_SUCCESS;
3330 }
3331    
3332 static int stun_no_debug(int fd, int argc, char *argv[])
3333 {
3334         if (argc != 3)
3335                 return RESULT_SHOWUSAGE;
3336         stundebug = 0;
3337         ast_cli(fd, "STUN Debugging Disabled\n");
3338         return RESULT_SUCCESS;
3339 }
3340
3341 static char debug_usage[] =
3342   "Usage: rtp debug [ip host[:port]]\n"
3343   "       Enable dumping of all RTP packets to and from host.\n";
3344
3345 static char no_debug_usage[] =
3346   "Usage: rtp debug off\n"
3347   "       Disable all RTP debugging\n";
3348
3349 static char stun_debug_usage[] =
3350   "Usage: stun debug\n"
3351   "       Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3352
3353 static char stun_no_debug_usage[] =
3354   "Usage: stun debug off\n"
3355   "       Disable STUN debugging\n";
3356
3357 static char rtcp_debug_usage[] =
3358   "Usage: rtcp debug [ip host[:port]]\n"
3359   "       Enable dumping of all RTCP packets to and from host.\n";
3360   
3361 static char rtcp_no_debug_usage[] =
3362   "Usage: rtcp debug off\n"
3363   "       Disable all RTCP debugging\n";
3364
3365 static char rtcp_stats_usage[] =
3366   "Usage: rtcp stats\n"
3367   "       Enable dumping of RTCP stats.\n";
3368   
3369 static char rtcp_no_stats_usage[] =
3370   "Usage: rtcp stats off\n"
3371   "       Disable all RTCP stats\n";
3372
3373 static struct ast_cli_entry cli_rtp[] = {
3374         { { "rtp", "debug", "ip", NULL },
3375         rtp_do_debug, "Enable RTP debugging on IP",
3376         debug_usage },
3377
3378         { { "rtp", "debug", NULL },
3379         rtp_do_debug, "Enable RTP debugging",
3380         debug_usage },
3381
3382         { { "rtp", "debug", "off", NULL },
3383         rtp_no_debug, "Disable RTP debugging",
3384         no_debug_usage },
3385
3386         { { "rtcp", "debug", "ip", NULL },
3387         rtcp_do_debug, "Enable RTCP debugging on IP",
3388         rtcp_debug_usage },
3389
3390         { { "rtcp", "debug", NULL },
3391         rtcp_do_debug, "Enable RTCP debugging",
3392         rtcp_debug_usage },
3393
3394         { { "rtcp", "debug", "off", NULL },
3395         rtcp_no_debug, "Disable RTCP debugging",
3396         rtcp_no_debug_usage },
3397
3398         { { "rtcp", "stats", NULL },
3399         rtcp_do_stats, "Enable RTCP stats",
3400         rtcp_stats_usage },
3401
3402         { { "rtcp", "stats", "off", NULL },
3403         rtcp_no_stats, "Disable RTCP stats",
3404         rtcp_no_stats_usage },
3405
3406         { { "stun", "debug", NULL },
3407         stun_do_debug, "Enable STUN debugging",
3408         stun_debug_usage },
3409
3410         { { "stun", "debug", "off", NULL },
3411         stun_no_debug, "Disable STUN debugging",
3412         stun_no_debug_usage },
3413 };
3414
3415 int ast_rtp_reload(void)
3416 {
3417         struct ast_config *cfg;
3418         const char *s;
3419
3420         rtpstart = 5000;
3421         rtpend = 31000;
3422         dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3423         cfg = ast_config_load("rtp.conf");
3424         if (cfg) {
3425                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
3426                         rtpstart = atoi(s);
3427                         if (rtpstart < 1024)
3428                                 rtpstart = 1024;
3429                         if (rtpstart > 65535)
3430                                 rtpstart = 65535;
3431                 }
3432                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
3433                         rtpend = atoi(s);
3434                         if (rtpend < 1024)
3435                                 rtpend = 1024;
3436                         if (rtpend > 65535)
3437                                 rtpend = 65535;
3438                 }
3439                 if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) {
3440                         rtcpinterval = atoi(s);
3441                         if (rtcpinterval == 0)
3442                                 rtcpinterval = 0; /* Just so we're clear... it's zero */
3443                         if (rtcpinterval < RTCP_MIN_INTERVALMS)
3444                                 rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */
3445                         if (rtcpinterval > RTCP_MAX_INTERVALMS)
3446                                 rtcpinterval = RTCP_MAX_INTERVALMS;
3447                 }
3448                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
3449 #ifdef SO_NO_CHECK
3450                         if (ast_false(s))
3451                                 nochecksums = 1;
3452                         else
3453                                 nochecksums = 0;
3454 #else
3455                         if (ast_false(s))
3456                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
3457 #endif
3458                 }
3459                 if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) {
3460                         dtmftimeout = atoi(s);
3461                         if ((dtmftimeout < 0) || (dtmftimeout > 20000)) {
3462                                 ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3463                                         dtmftimeout, DEFAULT_DTMF_TIMEOUT);
3464                                 dtmftimeout = DEFAULT_DTMF_TIMEOUT;
3465                         };
3466                 }
3467                 ast_config_destroy(cfg);
3468         }
3469         if (rtpstart >= rtpend) {
3470                 ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n");
3471                 rtpstart = 5000;
3472                 rtpend = 31000;
3473         }
3474         if (option_verbose > 1)
3475                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
3476         return 0;
3477 }
3478
3479 /*! \brief Initialize the RTP system in Asterisk */
3480 void ast_rtp_init(void)
3481 {
3482         ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry));
3483         ast_rtp_reload();
3484 }
3485