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