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