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