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