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