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