e688e54b4428a3b5d478a084dcb31eb925ae46e1
[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) | (0));
2004                 rtpheader[3] |= htonl((rtp->send_duration));
2005                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2006                 if (res < 0) 
2007                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2008                                 ast_inet_ntoa(rtp->them.sin_addr),
2009                                 ntohs(rtp->them.sin_port), strerror(errno));
2010                 if (rtp_debug_test_addr(&rtp->them))
2011                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2012                                     ast_inet_ntoa(rtp->them.sin_addr),
2013                                     ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2014                 /* Increment sequence number */
2015                 rtp->seqno++;
2016                 /* Increment duration */
2017                 rtp->send_duration += 160;
2018                 /* Clear marker bit and set seqno */
2019                 rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno));
2020         }
2021
2022         /* Since we received a begin, we can safely store the digit and disable any compensation */
2023         rtp->send_digit = digit;
2024         rtp->send_payload = payload;
2025
2026         return 0;
2027 }
2028
2029 /*! \brief Send continuation frame for DTMF */
2030 static int ast_rtp_senddigit_continuation(struct ast_rtp *rtp)
2031 {
2032         unsigned int *rtpheader;
2033         int hdrlen = 12, res = 0;
2034         char data[256];
2035
2036         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2037                 return 0;
2038
2039         /* Setup packet to send */
2040         rtpheader = (unsigned int *)data;
2041         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2042         rtpheader[1] = htonl(rtp->lastdigitts);
2043         rtpheader[2] = htonl(rtp->ssrc);
2044         rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (0));
2045         rtpheader[3] |= htonl((rtp->send_duration));
2046         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2047         
2048         /* Transmit */
2049         res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2050         if (res < 0)
2051                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2052                         ast_inet_ntoa(rtp->them.sin_addr),
2053                         ntohs(rtp->them.sin_port), strerror(errno));
2054         if (rtp_debug_test_addr(&rtp->them))
2055                 ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2056                             ast_inet_ntoa(rtp->them.sin_addr),
2057                             ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2058
2059         /* Increment sequence number */
2060         rtp->seqno++;
2061         /* Increment duration */
2062         rtp->send_duration += 160;
2063
2064         return 0;
2065 }
2066
2067 /*! \brief Send end packets for DTMF */
2068 int ast_rtp_senddigit_end(struct ast_rtp *rtp, char digit)
2069 {
2070         unsigned int *rtpheader;
2071         int hdrlen = 12, res = 0, i = 0;
2072         char data[256];
2073         
2074         /* If no address, then bail out */
2075         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
2076                 return 0;
2077         
2078         if ((digit <= '9') && (digit >= '0'))
2079                 digit -= '0';
2080         else if (digit == '*')
2081                 digit = 10;
2082         else if (digit == '#')
2083                 digit = 11;
2084         else if ((digit >= 'A') && (digit <= 'D'))
2085                 digit = digit - 'A' + 12;
2086         else if ((digit >= 'a') && (digit <= 'd'))
2087                 digit = digit - 'a' + 12;
2088         else {
2089                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
2090                 return 0;
2091         }
2092
2093         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2094
2095         rtpheader = (unsigned int *)data;
2096         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno));
2097         rtpheader[1] = htonl(rtp->lastdigitts);
2098         rtpheader[2] = htonl(rtp->ssrc);
2099         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
2100         /* Send duration to 100ms */
2101         rtpheader[3] |= htonl((rtp->send_duration));
2102         /* Set end bit */
2103         rtpheader[3] |= htonl((1 << 23));
2104         rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno));
2105         /* Send 3 termination packets */
2106         for (i = 0; i < 3; i++) {
2107                 res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them));
2108                 if (res < 0)
2109                         ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n",
2110                                 ast_inet_ntoa(rtp->them.sin_addr),
2111                                 ntohs(rtp->them.sin_port), strerror(errno));
2112                 if (rtp_debug_test_addr(&rtp->them))
2113                         ast_verbose("Sent RTP DTMF packet to %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2114                                     ast_inet_ntoa(rtp->them.sin_addr),
2115                                     ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
2116         }
2117         rtp->send_digit = 0;
2118         /* Increment lastdigitts */
2119         rtp->lastdigitts += 960;
2120         rtp->seqno++;
2121
2122         return res;
2123 }
2124
2125 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2126 int ast_rtcp_send_h261fur(void *data)
2127 {
2128         struct ast_rtp *rtp = data;
2129         int res;
2130
2131         rtp->rtcp->sendfur = 1;
2132         res = ast_rtcp_write(data);
2133         
2134         return res;
2135 }
2136
2137 /*! \brief Send RTCP sender's report */
2138 static int ast_rtcp_write_sr(void *data)
2139 {
2140         struct ast_rtp *rtp = data;
2141         int res;
2142         int len = 0;
2143         struct timeval now;
2144         unsigned int now_lsw;
2145         unsigned int now_msw;
2146         unsigned int *rtcpheader;
2147         unsigned int lost;
2148         unsigned int extended;
2149         unsigned int expected;
2150         unsigned int expected_interval;
2151         unsigned int received_interval;
2152         int lost_interval;
2153         int fraction;
2154         struct timeval dlsr;
2155         char bdata[512];
2156
2157         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2158                 return 0;
2159         
2160         if (!rtp->rtcp->them.sin_addr.s_addr) {  /* This'll stop rtcp for this rtp session */
2161                 ast_verbose("RTCP SR transmission error, rtcp halted %s\n",strerror(errno));
2162                 if (rtp->rtcp->schedid > 0)
2163                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2164                 rtp->rtcp->schedid = -1;
2165                 return 0;
2166         }
2167
2168         gettimeofday(&now, NULL);
2169         timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/
2170         rtcpheader = (unsigned int *)bdata;
2171         rtcpheader[1] = htonl(rtp->ssrc);               /* Our SSRC */
2172         rtcpheader[2] = htonl(now_msw);                 /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2173         rtcpheader[3] = htonl(now_lsw);                 /* now, LSW */
2174         rtcpheader[4] = htonl(rtp->lastts);             /* FIXME shouldn't be that, it should be now */
2175         rtcpheader[5] = htonl(rtp->txcount);            /* No. packets sent */
2176         rtcpheader[6] = htonl(rtp->txoctetcount);       /* No. bytes sent */
2177         len += 28;
2178         
2179         extended = rtp->cycles + rtp->lastrxseqno;
2180         expected = extended - rtp->seedrxseqno + 1;
2181         if (rtp->rxcount > expected) 
2182                 expected += rtp->rxcount - expected;
2183         lost = expected - rtp->rxcount;
2184         expected_interval = expected - rtp->rtcp->expected_prior;
2185         rtp->rtcp->expected_prior = expected;
2186         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2187         rtp->rtcp->received_prior = rtp->rxcount;
2188         lost_interval = expected_interval - received_interval;
2189         if (expected_interval == 0 || lost_interval <= 0)
2190                 fraction = 0;
2191         else
2192                 fraction = (lost_interval << 8) / expected_interval;
2193         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2194         rtcpheader[7] = htonl(rtp->themssrc);
2195         rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2196         rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2197         rtcpheader[10] = htonl((unsigned int)rtp->rxjitter);
2198         rtcpheader[11] = htonl(rtp->rtcp->themrxlsr);
2199         rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2200         len += 24;
2201         
2202         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1));
2203
2204         if (rtp->rtcp->sendfur) {
2205                 rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1);
2206                 rtcpheader[14] = htonl(rtp->ssrc);               /* Our SSRC */
2207                 len += 8;
2208                 rtp->rtcp->sendfur = 0;
2209         }
2210         
2211         /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ 
2212         /* it can change mid call, and SDES can't) */
2213         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2214         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2215         rtcpheader[(len/4)+2] = htonl(0x01 << 24);                    /* Empty for the moment */
2216         len += 12;
2217         
2218         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2219         if (res < 0) {
2220                 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));
2221                 if (rtp->rtcp->schedid > 0)
2222                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2223                 rtp->rtcp->schedid = -1;
2224                 return 0;
2225         }
2226         
2227         /* FIXME Don't need to get a new one */
2228         gettimeofday(&rtp->rtcp->txlsr, NULL);
2229         rtp->rtcp->sr_count++;
2230
2231         rtp->rtcp->lastsrtxcount = rtp->txcount;        
2232         
2233         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2234                 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
2235                 ast_verbose("  Our SSRC: %u\n", rtp->ssrc);
2236                 ast_verbose("  Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096);
2237                 ast_verbose("  Sent(RTP): %u\n", rtp->lastts);
2238                 ast_verbose("  Sent packets: %u\n", rtp->txcount);
2239                 ast_verbose("  Sent octets: %u\n", rtp->txoctetcount);
2240                 ast_verbose("  Report block:\n");
2241                 ast_verbose("  Fraction lost: %u\n", fraction);
2242                 ast_verbose("  Cumulative loss: %u\n", lost);
2243                 ast_verbose("  IA jitter: %.4f\n", rtp->rxjitter);
2244                 ast_verbose("  Their last SR: %u\n", rtp->rtcp->themrxlsr);
2245                 ast_verbose("  DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0));
2246         }
2247         return res;
2248 }
2249
2250 /*! \brief Send RTCP recepient's report */
2251 static int ast_rtcp_write_rr(void *data)
2252 {
2253         struct ast_rtp *rtp = data;
2254         int res;
2255         int len = 32;
2256         unsigned int lost;
2257         unsigned int extended;
2258         unsigned int expected;
2259         unsigned int expected_interval;
2260         unsigned int received_interval;
2261         int lost_interval;
2262         struct timeval now;
2263         unsigned int *rtcpheader;
2264         char bdata[1024];
2265         struct timeval dlsr;
2266         int fraction;
2267
2268         if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0))
2269                 return 0;
2270           
2271         if (!rtp->rtcp->them.sin_addr.s_addr) {
2272                 ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno));
2273                 if (rtp->rtcp->schedid > 0)
2274                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2275                 rtp->rtcp->schedid = -1;
2276                 return 0;
2277         }
2278
2279         extended = rtp->cycles + rtp->lastrxseqno;
2280         expected = extended - rtp->seedrxseqno + 1;
2281         lost = expected - rtp->rxcount;
2282         expected_interval = expected - rtp->rtcp->expected_prior;
2283         rtp->rtcp->expected_prior = expected;
2284         received_interval = rtp->rxcount - rtp->rtcp->received_prior;
2285         rtp->rtcp->received_prior = rtp->rxcount;
2286         lost_interval = expected_interval - received_interval;
2287         if (expected_interval == 0 || lost_interval <= 0)
2288                 fraction = 0;
2289         else
2290                 fraction = (lost_interval << 8) / expected_interval;
2291         gettimeofday(&now, NULL);
2292         timersub(&now, &rtp->rtcp->rxlsr, &dlsr);
2293         rtcpheader = (unsigned int *)bdata;
2294         rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1));
2295         rtcpheader[1] = htonl(rtp->ssrc);
2296         rtcpheader[2] = htonl(rtp->themssrc);
2297         rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff));
2298         rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff)));
2299         rtcpheader[5] = htonl((unsigned int)rtp->rxjitter);
2300         rtcpheader[6] = htonl(rtp->rtcp->themrxlsr);
2301         rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000);
2302
2303         if (rtp->rtcp->sendfur) {
2304                 rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */
2305                 rtcpheader[9] = htonl(rtp->ssrc);               /* Our SSRC */
2306                 len += 8;
2307                 rtp->rtcp->sendfur = 0;
2308         }
2309
2310         /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos 
2311         it can change mid call, and SDES can't) */
2312         rtcpheader[len/4]     = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2);
2313         rtcpheader[(len/4)+1] = htonl(rtp->ssrc);               /* Our SSRC */
2314         rtcpheader[(len/4)+2] = htonl(0x01 << 24);              /* Empty for the moment */
2315         len += 12;
2316         
2317         res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them));
2318
2319         if (res < 0) {
2320                 ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno));
2321                 /* Remove the scheduler */
2322                 if (rtp->rtcp->schedid > 0)
2323                         ast_sched_del(rtp->sched, rtp->rtcp->schedid);
2324                 rtp->rtcp->schedid = -1;
2325                 return 0;
2326         }
2327
2328         rtp->rtcp->rr_count++;
2329
2330         if (rtcp_debug_test_addr(&rtp->rtcp->them)) {
2331                 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2332                         "  Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" 
2333                         "  IA jitter: %.4f\n" 
2334                         "  Their last SR: %u\n" 
2335                         "  DLSR: %4.4f (sec)\n\n",
2336                         ast_inet_ntoa(rtp->rtcp->them.sin_addr),
2337                         ntohs(rtp->rtcp->them.sin_port),
2338                         rtp->ssrc, rtp->themssrc, fraction, lost,
2339                         rtp->rxjitter,
2340                         rtp->rtcp->themrxlsr,
2341                         (double)(ntohl(rtcpheader[7])/65536.0));
2342         }
2343
2344         return res;
2345 }
2346
2347 /*! \brief Write and RTCP packet to the far end
2348  * \note Decide if we are going to send an SR (with Reception Block) or RR 
2349  * RR is sent if we have not sent any rtp packets in the previous interval */
2350 static int ast_rtcp_write(void *data)
2351 {
2352         struct ast_rtp *rtp = data;
2353         int res;
2354         
2355         if (rtp->txcount > rtp->rtcp->lastsrtxcount)
2356                 res = ast_rtcp_write_sr(data);
2357         else
2358                 res = ast_rtcp_write_rr(data);
2359         
2360         return res;
2361 }
2362
2363 /*! \brief generate comfort noice (CNG) */
2364 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
2365 {
2366         unsigned int *rtpheader;
2367         int hdrlen = 12;
2368         int res;
2369         int payload;
2370         char data[256];
2371         level = 127 - (level & 0x7f);
2372         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
2373
2374         /* If we have no peer, return immediately */    
2375         if (!rtp->them.sin_addr.s_addr)
2376                 return 0;
2377
2378         rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2379
2380         /* Get a pointer to the header */
2381         rtpheader = (unsigned int *)data;
2382         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
2383         rtpheader[1] = htonl(rtp->lastts);
2384         rtpheader[2] = htonl(rtp->ssrc); 
2385         data[12] = level;
2386         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2387                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2388                 if (res <0) 
2389                         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));
2390                 if (rtp_debug_test_addr(&rtp->them))
2391                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %u, len %d)\n"
2392                                         , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);            
2393                    
2394         }
2395         return 0;
2396 }
2397
2398 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
2399 {
2400         unsigned char *rtpheader;
2401         int hdrlen = 12;
2402         int res;
2403         unsigned int ms;
2404         int pred;
2405         int mark = 0;
2406
2407         ms = calc_txstamp(rtp, &f->delivery);
2408         /* Default prediction */
2409         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
2410                 pred = rtp->lastts + f->samples;
2411
2412                 /* Re-calculate last TS */
2413                 rtp->lastts = rtp->lastts + ms * 8;
2414                 if (ast_tvzero(f->delivery)) {
2415                         /* If this isn't an absolute delivery time, Check if it is close to our prediction, 
2416                            and if so, go with our prediction */
2417                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
2418                                 rtp->lastts = pred;
2419                         else {
2420                                 if (option_debug > 2)
2421                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
2422                                 mark = 1;
2423                         }
2424                 }
2425         } else {
2426                 mark = f->subclass & 0x1;
2427                 pred = rtp->lastovidtimestamp + f->samples;
2428                 /* Re-calculate last TS */
2429                 rtp->lastts = rtp->lastts + ms * 90;
2430                 /* If it's close to our prediction, go for it */
2431                 if (ast_tvzero(f->delivery)) {
2432                         if (abs(rtp->lastts - pred) < 7200) {
2433                                 rtp->lastts = pred;
2434                                 rtp->lastovidtimestamp += f->samples;
2435                         } else {
2436                                 if (option_debug > 2)
2437                                         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);
2438                                 rtp->lastovidtimestamp = rtp->lastts;
2439                         }
2440                 }
2441         }
2442         /* If the timestamp for non-digit packets has moved beyond the timestamp
2443            for digits, update the digit timestamp.
2444         */
2445         if (rtp->lastts > rtp->lastdigitts)
2446                 rtp->lastdigitts = rtp->lastts;
2447
2448         if (f->has_timing_info)
2449                 rtp->lastts = f->ts * 8;
2450
2451         /* Get a pointer to the header */
2452         rtpheader = (unsigned char *)(f->data - hdrlen);
2453
2454         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
2455         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
2456         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); 
2457
2458         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
2459                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
2460                 if (res <0) {
2461                         if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) {
2462                                 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));
2463                         } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) {
2464                                 /* Only give this error message once if we are not RTP debugging */
2465                                 if (option_debug || rtpdebug)
2466                                         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));
2467                                 ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN);
2468                         }
2469                 } else {
2470                         rtp->txcount++;
2471                         rtp->txoctetcount +=(res - hdrlen);
2472                         
2473                         if (rtp->rtcp && rtp->rtcp->schedid < 1) 
2474                             rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp);
2475                 }
2476                                 
2477                 if (rtp_debug_test_addr(&rtp->them))
2478                         ast_verbose("Sent RTP packet to      %s:%d (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2479                                         ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
2480         }
2481
2482         rtp->seqno++;
2483
2484         return 0;
2485 }
2486
2487 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
2488 {
2489         struct ast_frame *f;
2490         int codec;
2491         int hdrlen = 12;
2492         int subclass;
2493         
2494
2495         /* If we have no peer, return immediately */    
2496         if (!rtp->them.sin_addr.s_addr)
2497                 return 0;
2498
2499         /* If there is no data length, return immediately */
2500         if (!_f->datalen) 
2501                 return 0;
2502         
2503         /* Make sure we have enough space for RTP header */
2504         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
2505                 ast_log(LOG_WARNING, "RTP can only send voice and video\n");
2506                 return -1;
2507         }
2508
2509         subclass = _f->subclass;
2510         if (_f->frametype == AST_FRAME_VIDEO)
2511                 subclass &= ~0x1;
2512
2513         codec = ast_rtp_lookup_code(rtp, 1, subclass);
2514         if (codec < 0) {
2515                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
2516                 return -1;
2517         }
2518
2519         if (rtp->lasttxformat != subclass) {
2520                 /* New format, reset the smoother */
2521                 if (option_debug)
2522                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
2523                 rtp->lasttxformat = subclass;
2524                 if (rtp->smoother)
2525                         ast_smoother_free(rtp->smoother);
2526                 rtp->smoother = NULL;
2527         }
2528
2529
2530         switch(subclass) {
2531         case AST_FORMAT_SLINEAR:
2532                 if (!rtp->smoother) {
2533                         rtp->smoother = ast_smoother_new(320);
2534                 }
2535                 if (!rtp->smoother) {
2536                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2537                         return -1;
2538                 }
2539                 ast_smoother_feed_be(rtp->smoother, _f);
2540                 
2541                 while((f = ast_smoother_read(rtp->smoother)))
2542                         ast_rtp_raw_write(rtp, f, codec);
2543                 break;
2544         case AST_FORMAT_ULAW:
2545         case AST_FORMAT_ALAW:
2546                 if (!rtp->smoother) {
2547                         rtp->smoother = ast_smoother_new(160);
2548                 }
2549                 if (!rtp->smoother) {
2550                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2551                         return -1;
2552                 }
2553                 ast_smoother_feed(rtp->smoother, _f);
2554                 
2555                 while((f = ast_smoother_read(rtp->smoother)))
2556                         ast_rtp_raw_write(rtp, f, codec);
2557                 break;
2558         case AST_FORMAT_ADPCM:
2559         case AST_FORMAT_G726:
2560         case AST_FORMAT_G726_AAL2:
2561                 if (!rtp->smoother) {
2562                         rtp->smoother = ast_smoother_new(80);
2563                 }
2564                 if (!rtp->smoother) {
2565                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
2566                         return -1;
2567                 }
2568                 ast_smoother_feed(rtp->smoother, _f);
2569                 
2570                 while((f = ast_smoother_read(rtp->smoother)))
2571                         ast_rtp_raw_write(rtp, f, codec);
2572                 break;
2573         case AST_FORMAT_G729A:
2574                 if (!rtp->smoother) {
2575                         rtp->smoother = ast_smoother_new(20);
2576                         if (rtp->smoother)
2577                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
2578                 }
2579                 if (!rtp->smoother) {
2580                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
2581                         return -1;
2582                 }
2583                 ast_smoother_feed(rtp->smoother, _f);
2584                 
2585                 while((f = ast_smoother_read(rtp->smoother)))
2586                         ast_rtp_raw_write(rtp, f, codec);
2587                 break;
2588         case AST_FORMAT_GSM:
2589                 if (!rtp->smoother) {
2590                         rtp->smoother = ast_smoother_new(33);
2591                 }
2592                 if (!rtp->smoother) {
2593                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
2594                         return -1;
2595                 }
2596                 ast_smoother_feed(rtp->smoother, _f);
2597                 while((f = ast_smoother_read(rtp->smoother)))
2598                         ast_rtp_raw_write(rtp, f, codec);
2599                 break;
2600         case AST_FORMAT_ILBC:
2601                 if (!rtp->smoother) {
2602                         rtp->smoother = ast_smoother_new(50);
2603                 }
2604                 if (!rtp->smoother) {
2605                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
2606                         return -1;
2607                 }
2608                 ast_smoother_feed(rtp->smoother, _f);
2609                 while((f = ast_smoother_read(rtp->smoother)))
2610                         ast_rtp_raw_write(rtp, f, codec);
2611                 break;
2612         default:        
2613                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
2614                 /* fall through to... */
2615         case AST_FORMAT_H261:
2616         case AST_FORMAT_H263:
2617         case AST_FORMAT_H263_PLUS:
2618         case AST_FORMAT_H264:
2619         case AST_FORMAT_G723_1:
2620         case AST_FORMAT_LPC10:
2621         case AST_FORMAT_SPEEX:
2622                 /* Don't buffer outgoing frames; send them one-per-packet: */
2623                 if (_f->offset < hdrlen) {
2624                         f = ast_frdup(_f);
2625                 } else {
2626                         f = _f;
2627                 }
2628                 ast_rtp_raw_write(rtp, f, codec);
2629         }
2630                 
2631         return 0;
2632 }
2633
2634 /*! \brief Unregister interface to channel driver */
2635 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
2636 {
2637         AST_LIST_LOCK(&protos);
2638         AST_LIST_REMOVE(&protos, proto, list);
2639         AST_LIST_UNLOCK(&protos);
2640 }
2641
2642 /*! \brief Register interface to channel driver */
2643 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
2644 {
2645         struct ast_rtp_protocol *cur;
2646
2647         AST_LIST_LOCK(&protos);
2648         AST_LIST_TRAVERSE(&protos, cur, list) { 
2649                 if (!strcmp(cur->type, proto->type)) {
2650                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
2651                         AST_LIST_UNLOCK(&protos);
2652                         return -1;
2653                 }
2654         }
2655         AST_LIST_INSERT_HEAD(&protos, proto, list);
2656         AST_LIST_UNLOCK(&protos);
2657         
2658         return 0;
2659 }
2660
2661 /*! \brief Bridge loop for true native bridge (reinvite) */
2662 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)
2663 {
2664         struct ast_frame *fr = NULL;
2665         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2666         int oldcodec0 = codec0, oldcodec1 = codec1;
2667         struct sockaddr_in ac1 = {0,}, vac1 = {0,}, ac0 = {0,}, vac0 = {0,};
2668         struct sockaddr_in t1 = {0,}, vt1 = {0,}, t0 = {0,}, vt0 = {0,};
2669
2670         /* Set it up so audio goes directly between the two endpoints */
2671
2672         /* Test the first channel */
2673         if (!(pr0->set_rtp_peer(c0, p1, vp1, codec1, ast_test_flag(p1, FLAG_NAT_ACTIVE)))) {
2674                 ast_rtp_get_peer(p1, &ac1);
2675                 if (vp1)
2676                         ast_rtp_get_peer(vp1, &vac1);
2677         } else
2678                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
2679         
2680         /* Test the second channel */
2681         if (!(pr1->set_rtp_peer(c1, p0, vp0, codec0, ast_test_flag(p0, FLAG_NAT_ACTIVE)))) {
2682                 ast_rtp_get_peer(p0, &ac0);
2683                 if (vp0)
2684                         ast_rtp_get_peer(vp0, &vac0);
2685         } else
2686                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c1->name, c0->name);
2687
2688         /* Now we can unlock and move into our loop */
2689         ast_channel_unlock(c0);
2690         ast_channel_unlock(c1);
2691
2692         /* Throw our channels into the structure and enter the loop */
2693         cs[0] = c0;
2694         cs[1] = c1;
2695         cs[2] = NULL;
2696         for (;;) {
2697                 /* Check if anything changed */
2698                 if ((c0->tech_pvt != pvt0) ||
2699                     (c1->tech_pvt != pvt1) ||
2700                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2701                         ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2702                         if (c0->tech_pvt == pvt0)
2703                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2704                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2705                         if (c1->tech_pvt == pvt1)
2706                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2707                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2708                         return AST_BRIDGE_RETRY;
2709                 }
2710
2711                 /* Check if they have changed their address */
2712                 ast_rtp_get_peer(p1, &t1);
2713                 if (vp1)
2714                         ast_rtp_get_peer(vp1, &vt1);
2715                 if (pr1->get_codec)
2716                         codec1 = pr1->get_codec(c1);
2717                 ast_rtp_get_peer(p0, &t0);
2718                 if (vp0)
2719                         ast_rtp_get_peer(vp0, &vt0);
2720                 if (pr0->get_codec)
2721                         codec0 = pr0->get_codec(c0);
2722                 if ((inaddrcmp(&t1, &ac1)) ||
2723                     (vp1 && inaddrcmp(&vt1, &vac1)) ||
2724                     (codec1 != oldcodec1)) {
2725                         if (option_debug > 1) {
2726                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2727                                         c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port), codec1);
2728                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2729                                         c1->name, ast_inet_ntoa(vt1.sin_addr), ntohs(vt1.sin_port), codec1);
2730                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2731                                         c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
2732                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2733                                         c1->name, ast_inet_ntoa(vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
2734                         }
2735                         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)))
2736                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
2737                         memcpy(&ac1, &t1, sizeof(ac1));
2738                         memcpy(&vac1, &vt1, sizeof(vac1));
2739                         oldcodec1 = codec1;
2740                 }
2741                 if ((inaddrcmp(&t0, &ac0)) ||
2742                     (vp0 && inaddrcmp(&vt0, &vac0))) {
2743                         if (option_debug > 1) {
2744                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2745                                         c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port), codec0);
2746                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
2747                                         c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
2748                         }
2749                         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)))
2750                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
2751                         memcpy(&ac0, &t0, sizeof(ac0));
2752                         memcpy(&vac0, &vt0, sizeof(vac0));
2753                         oldcodec0 = codec0;
2754                 }
2755
2756                 /* Wait for frame to come in on the channels */
2757                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2758                         if (!timeoutms)
2759                                 return AST_BRIDGE_RETRY;
2760                         if (option_debug)
2761                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2762                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2763                                 break;
2764                         continue;
2765                 }
2766                 fr = ast_read(who);
2767                 other = (who == c0) ? c1 : c0;
2768                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2769                             (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
2770                              ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
2771                         /* Break out of bridge */
2772                         *fo = fr;
2773                         *rc = who;
2774                         if (option_debug)
2775                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2776                         if (c0->tech_pvt == pvt0)
2777                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0, 0))
2778                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c0->name);
2779                         if (c1->tech_pvt == pvt1)
2780                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0, 0))
2781                                         ast_log(LOG_WARNING, "Channel '%s' failed to break RTP bridge\n", c1->name);
2782                         return AST_BRIDGE_COMPLETE;
2783                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2784                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2785                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2786                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2787                                 ast_indicate(other, fr->subclass);
2788                                 ast_frfree(fr);
2789                         } else {
2790                                 *fo = fr;
2791                                 *rc = who;
2792                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
2793                                 return AST_BRIDGE_COMPLETE;
2794                         }
2795                 } else {
2796                         if ((fr->frametype == AST_FRAME_DTMF) ||
2797                             (fr->frametype == AST_FRAME_VOICE) ||
2798                             (fr->frametype == AST_FRAME_VIDEO)) {
2799                                 ast_write(other, fr);
2800                         }
2801                         ast_frfree(fr);
2802                 }
2803                 /* Swap priority */
2804                 cs[2] = cs[0];
2805                 cs[0] = cs[1];
2806                 cs[1] = cs[2];
2807         }
2808
2809         return AST_BRIDGE_FAILED;
2810 }
2811
2812 /*! \brief P2P RTP/RTCP Callback */
2813 static int p2p_rtp_callback(int *id, int fd, short events, void *cbdata)
2814 {
2815         int res = 0, hdrlen = 12;
2816         struct sockaddr_in sin;
2817         socklen_t len;
2818         unsigned int *header;
2819         struct ast_rtp *rtp = cbdata;
2820         int is_rtp = 0, is_rtcp = 0;
2821
2822         if (!rtp)
2823                 return 1;
2824
2825         len = sizeof(sin);
2826         if ((res = recvfrom(fd, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len)) < 0)
2827                 return 1;
2828
2829         header = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
2830
2831         /* Determine what this file descriptor is for */
2832         if (rtp->s == fd)
2833                 is_rtp = 1;
2834         else if (rtp->rtcp && rtp->rtcp->s == fd)
2835                 is_rtcp = 1;
2836
2837         /* If NAT support is turned on, then see if we need to change their address */
2838         if (rtp->nat) {
2839                 /* If this is for RTP, check that - if it's for RTCP, check that */
2840                 if (is_rtp) {
2841                         if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2842                             (rtp->them.sin_port != sin.sin_port)) {
2843                                 rtp->them = sin;
2844                                 rtp->rxseqno = 0;
2845                                 ast_set_flag(rtp, FLAG_NAT_ACTIVE);
2846                                 if (option_debug || rtpdebug)
2847                                         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));
2848                         }
2849                 } else if (is_rtcp) {
2850                         if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
2851                             (rtp->rtcp->them.sin_port != sin.sin_port)) {
2852                                 rtp->rtcp->them = sin;
2853                                 if (option_debug || rtpdebug)
2854                                         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));
2855                         }
2856                 }
2857         }
2858
2859         /* If this came from the RTP stream, write out via RTP - if it's RTCP, write out via RTCP */
2860         if (ast_rtp_get_bridged(rtp)) {
2861                 if (is_rtp)
2862                         bridge_p2p_rtp_write(rtp, header, res, hdrlen);
2863                 else if (is_rtcp)
2864                         bridge_p2p_rtcp_write(rtp, header, res);
2865         }
2866
2867         return 1;
2868 }
2869
2870 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
2871 static int p2p_callback_enable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2872 {
2873         /* If we need DTMF or we have no IO structure, then we can't do direct callback */
2874         if (ast_test_flag(rtp, FLAG_P2P_NEED_DTMF) || !rtp->io)
2875                 return 0;
2876
2877         /* If the RTP structure is already in callback mode, remove it temporarily */
2878         if (rtp->ioid) {
2879                 ast_io_remove(rtp->io, rtp->ioid);
2880                 rtp->ioid = NULL;
2881         }
2882
2883         /* Steal the file descriptors from the channel and stash them away */
2884         fds[0] = chan->fds[0];
2885         fds[1] = chan->fds[1];
2886         chan->fds[0] = -1;
2887         chan->fds[1] = -1;
2888
2889         /* Now, fire up callback mode */
2890         iod[0] = ast_io_add(rtp->io, fds[0], p2p_rtp_callback, AST_IO_IN, rtp);
2891         if (fds[1] >= 0)
2892                 iod[1] = ast_io_add(rtp->io, fds[1], p2p_rtp_callback, AST_IO_IN, rtp);
2893
2894         return 1;
2895 }
2896
2897 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
2898 static int p2p_callback_disable(struct ast_channel *chan, struct ast_rtp *rtp, int *fds, int **iod)
2899 {
2900         ast_channel_lock(chan);
2901         /* Remove the callback from the IO context */
2902         ast_io_remove(rtp->io, iod[0]);
2903         ast_io_remove(rtp->io, iod[1]);
2904         /* Restore file descriptors */
2905         chan->fds[0] = fds[0];
2906         chan->fds[1] = fds[1];
2907         ast_channel_unlock(chan);
2908         /* Restore callback mode if previously used */
2909         if (ast_test_flag(rtp, FLAG_CALLBACK_MODE))
2910             rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
2911         return 0;
2912 }
2913
2914 /*! \brief Bridge loop for partial native bridge (packet2packet) */
2915 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)
2916 {
2917         struct ast_frame *fr = NULL;
2918         struct ast_channel *who = NULL, *other = NULL, *cs[3] = {NULL, };
2919         int p0_fds[2] = {-1, -1}, p1_fds[2] = {-1, -1};
2920         int *p0_iod[2] = {NULL, }, *p1_iod[2] = {NULL, };
2921         int p0_callback = 0, p1_callback = 0;
2922         enum ast_bridge_result res = AST_BRIDGE_FAILED;
2923
2924         /* Okay, setup each RTP structure to do P2P forwarding */
2925         ast_clear_flag(p0, FLAG_P2P_SENT_MARK);
2926         p0->bridged = p1;
2927         ast_clear_flag(p1, FLAG_P2P_SENT_MARK);
2928         p1->bridged = p0;
2929         if (vp0) {
2930                 ast_clear_flag(vp0, FLAG_P2P_SENT_MARK);
2931                 vp0->bridged = vp1;
2932                 ast_clear_flag(vp1, FLAG_P2P_SENT_MARK);
2933                 vp1->bridged = vp0;
2934         }
2935
2936         /* Activate callback modes if possible */
2937         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
2938         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
2939
2940         /* Now let go of the channel locks and be on our way */
2941         ast_channel_unlock(c0);
2942         ast_channel_unlock(c1);
2943
2944         /* Go into a loop forwarding frames until we don't need to anymore */
2945         cs[0] = c0;
2946         cs[1] = c1;
2947         cs[2] = NULL;
2948         for (;;) {
2949                 /* Check if anything changed */
2950                 if ((c0->tech_pvt != pvt0) ||
2951                     (c1->tech_pvt != pvt1) ||
2952                     (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
2953                         ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
2954                         res = AST_BRIDGE_RETRY;
2955                         break;
2956                 }
2957                 /* Wait on a channel to feed us a frame */
2958                 if (!(who = ast_waitfor_n(cs, 2, &timeoutms))) {
2959                         if (!timeoutms) {
2960                                 res = AST_BRIDGE_RETRY;
2961                                 break;
2962                         }
2963                         if (option_debug)
2964                                 ast_log(LOG_NOTICE, "Ooh, empty read...\n");
2965                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
2966                                 break;
2967                         continue;
2968                 }
2969                 /* Read in frame from channel */
2970                 fr = ast_read(who);
2971                 other = (who == c0) ? c1 : c0;
2972                 /* Dependong on the frame we may need to break out of our bridge */
2973                 if (!fr || ((fr->frametype == AST_FRAME_DTMF) &&
2974                             ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) |
2975                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)))) {
2976                         /* Record received frame and who */
2977                         *fo = fr;
2978                         *rc = who;
2979                         if (option_debug)
2980                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", fr ? "digit" : "hangup");
2981                         res = AST_BRIDGE_COMPLETE;
2982                         break;
2983                 } else if ((fr->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
2984                         if ((fr->subclass == AST_CONTROL_HOLD) ||
2985                             (fr->subclass == AST_CONTROL_UNHOLD) ||
2986                             (fr->subclass == AST_CONTROL_VIDUPDATE)) {
2987                                 /* If we are going on hold, then break callback mode */
2988                                 if (fr->subclass == AST_CONTROL_HOLD) {
2989                                         if (p0_callback)
2990                                                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
2991                                         if (p1_callback)
2992                                                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
2993                                 } else if (fr->subclass == AST_CONTROL_UNHOLD) {
2994                                         /* If we are off hold, then go back to callback mode */
2995                                         p0_callback = p2p_callback_enable(c0, p0, &p0_fds[0], &p0_iod[0]);
2996                                         p1_callback = p2p_callback_enable(c1, p1, &p1_fds[0], &p1_iod[0]);
2997                                 }
2998                                 ast_indicate(other, fr->subclass);
2999                                 ast_frfree(fr);
3000                         } else {
3001                                 *fo = fr;
3002                                 *rc = who;
3003                                 ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr->subclass, who->name);
3004                                 res = AST_BRIDGE_COMPLETE;
3005                                 break;
3006                         }
3007                 } else {
3008                         /* If this is a DTMF, voice, or video frame write it to the other channel */
3009                         if ((fr->frametype == AST_FRAME_DTMF) ||
3010                             (fr->frametype == AST_FRAME_VOICE) ||
3011                             (fr->frametype == AST_FRAME_VIDEO)) {
3012                                 ast_write(other, fr);
3013                         }
3014                         ast_frfree(fr);
3015                 }
3016                 /* Swap priority */
3017                 cs[2] = cs[0];
3018                 cs[0] = cs[1];
3019                 cs[1] = cs[2];
3020         }
3021
3022         /* If we are totally avoiding the core, then restore our link to it */
3023         if (p0_callback)
3024                 p0_callback = p2p_callback_disable(c0, p0, &p0_fds[0], &p0_iod[0]);
3025         if (p1_callback)
3026                 p1_callback = p2p_callback_disable(c1, p1, &p1_fds[0], &p1_iod[0]);
3027
3028         /* Break out of the direct bridge */
3029         p0->bridged = NULL;
3030         p1->bridged = NULL;
3031         if (vp0) {
3032                 vp0->bridged = NULL;
3033                 vp1->bridged = NULL;
3034         }
3035
3036         return res;
3037 }
3038
3039 /*! \brief Bridge calls. If possible and allowed, initiate
3040         re-invite so the peers exchange media directly outside 
3041         of Asterisk. */
3042 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)
3043 {
3044         struct ast_rtp *p0 = NULL, *p1 = NULL;          /* Audio RTP Channels */
3045         struct ast_rtp *vp0 = NULL, *vp1 = NULL;        /* Video RTP channels */
3046         struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL;
3047         enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED;
3048         enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED;
3049         enum ast_bridge_result res = AST_BRIDGE_FAILED;
3050         int codec0 = 0, codec1 = 0;
3051         void *pvt0 = NULL, *pvt1 = NULL;
3052
3053         /* Lock channels */
3054         ast_channel_lock(c0);
3055         while(ast_channel_trylock(c1)) {
3056                 ast_channel_unlock(c0);
3057                 usleep(1);
3058                 ast_channel_lock(c0);
3059         }
3060
3061         /* Find channel driver interfaces */
3062         if (!(pr0 = get_proto(c0))) {
3063                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
3064                 ast_channel_unlock(c0);
3065                 ast_channel_unlock(c1);
3066                 return AST_BRIDGE_FAILED;
3067         }
3068         if (!(pr1 = get_proto(c1))) {
3069                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
3070                 ast_channel_unlock(c0);
3071                 ast_channel_unlock(c1);
3072                 return AST_BRIDGE_FAILED;
3073         }
3074
3075         /* Get channel specific interface structures */
3076         pvt0 = c0->tech_pvt;
3077         pvt1 = c1->tech_pvt;
3078
3079         /* Get audio and video interface (if native bridge is possible) */
3080         audio_p0_res = pr0->get_rtp_info(c0, &p0);
3081         video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED;
3082         audio_p1_res = pr1->get_rtp_info(c1, &p1);
3083         video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED;
3084
3085         /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3086         if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE))
3087                 audio_p0_res = AST_RTP_GET_FAILED;
3088         if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE))
3089                 audio_p1_res = AST_RTP_GET_FAILED;
3090
3091         /* Check if a bridge is possible (partial/native) */
3092         if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) {
3093                 /* Somebody doesn't want to play... */
3094                 ast_channel_unlock(c0);
3095                 ast_channel_unlock(c1);
3096                 return AST_BRIDGE_FAILED_NOWARN;
3097         }
3098
3099         /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3100         if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
3101                 ast_set_flag(p0, FLAG_P2P_NEED_DTMF);
3102                 audio_p0_res = AST_RTP_TRY_PARTIAL;
3103         }
3104
3105         if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
3106                 ast_set_flag(p1, FLAG_P2P_NEED_DTMF);
3107                 audio_p1_res = AST_RTP_TRY_PARTIAL;
3108         }
3109
3110         /* Get codecs from both sides */
3111         codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0;
3112         codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0;
3113         if (pr0->get_codec && pr1->get_codec) {
3114                 /* Hey, we can't do native bridging if both parties speak different codecs */
3115                 if (!(codec0 & codec1)) {
3116                         if (option_debug)
3117                                 ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1);
3118                         ast_channel_unlock(c0);
3119                         ast_channel_unlock(c1);
3120                         return AST_BRIDGE_FAILED_NOWARN;
3121                 }
3122         }
3123
3124         /* If either side can only do a partial bridge, then don't try for a true native bridge */
3125         if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) {
3126                 if (option_verbose > 2)
3127                         ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name);
3128                 res = bridge_p2p_loop(c0, c1, p0, p1, vp0, vp1, timeoutms, flags, fo, rc, pvt0, pvt1);
3129         } else {
3130                 if (option_verbose > 2) 
3131                         ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);
3132                 res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1);
3133         }
3134
3135         return res;
3136 }
3137
3138 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
3139 {
3140         struct hostent *hp;
3141         struct ast_hostent ahp;
3142         int port = 0;
3143         char *p, *arg;
3144
3145         if (argc != 4)
3146                 return RESULT_SHOWUSAGE;
3147         arg = argv[3];
3148         p = strstr(arg, ":");
3149         if (p) {
3150                 *p = '\0';
3151                 p++;
3152                 port = atoi(p);
3153         }
3154         hp = ast_gethostbyname(arg, &ahp);
3155         if (hp == NULL)
3156                 return RESULT_SHOWUSAGE;
3157         rtpdebugaddr.sin_family = AF_INET;
3158         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
3159         rtpdebugaddr.sin_port = htons(port);