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