2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2006, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
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.
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.
22 * \brief Supports RTP and RTCP with Symmetric RTP support for NAT traversal.
24 * \author Mark Spencer <markster@digium.com>
26 * \note RTP is defined in RFC 3550.
31 ASTERISK_FILE_VERSION(__FILE__
, "$Revision$")
40 #include <netinet/in.h>
42 #include <sys/socket.h>
43 #include <arpa/inet.h>
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"
60 #define MAX_TIMESTAMP_SKEW 640
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 */
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
76 #define DEFAULT_DTMF_TIMEOUT 3000 /*!< samples */
78 static int dtmftimeout
= DEFAULT_DTMF_TIMEOUT
;
80 static int rtpstart
; /*!< First port for RTP sessions (set in rtp.conf) */
81 static int rtpend
; /*!< Last port for RTP sessions (set in rtp.conf) */
82 static int rtpdebug
; /*!< Are we debugging? */
83 static int rtcpdebug
; /*!< Are we debugging RTCP? */
84 static int rtcpstats
; /*!< Are we debugging RTCP? */
85 static int rtcpinterval
= RTCP_DEFAULT_INTERVALMS
; /*!< Time between rtcp reports in millisecs */
86 static int stundebug
; /*!< 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 */
90 static int nochecksums
;
93 /* Uncomment this to enable more intense native bridging, but note: this is currently buggy */
94 /* #define P2P_INTENSE */
97 * \brief Structure representing a RTP session.
99 * 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 [...]"
102 /*! \brief The value of each payload format mapping: */
103 struct rtpPayloadType
{
104 int isAstFormat
; /*!< whether the following code is an AST_FORMAT */
109 /*! \brief RTP session description */
113 unsigned char rawdata
[8192 + AST_FRIENDLY_OFFSET
];
114 unsigned int ssrc
; /*!< Synchronization source, RFC 3550, page 10. */
115 unsigned int themssrc
; /*!< Their SSRC */
118 unsigned int lastrxts
;
119 unsigned int lastividtimestamp
;
120 unsigned int lastovidtimestamp
;
121 unsigned int lasteventseqn
;
122 int lastrxseqno
; /*!< Last received sequence number */
123 unsigned short seedrxseqno
; /*!< What sequence number did they start with?*/
124 unsigned int seedrxts
; /*!< What RTP timestamp did they start with? */
125 unsigned int rxcount
; /*!< How many packets have we received? */
126 unsigned int rxoctetcount
; /*!< How many octets have we received? should be rxcount *160*/
127 unsigned int txcount
; /*!< How many packets have we sent? */
128 unsigned int txoctetcount
; /*!< How many octets have we sent? (txcount*160)*/
129 unsigned int cycles
; /*!< Shifted count of sequence number cycles */
130 double rxjitter
; /*!< Interarrival jitter at the moment */
131 double rxtransit
; /*!< Relative transit time for previous packet */
135 int rtptimeout
; /*!< RTP timeout time (negative or zero means disabled, negative value means temporarily disabled) */
136 int rtpholdtimeout
; /*!< RTP timeout when on hold (negative or zero means disabled, negative value means temporarily disabled). */
137 int rtpkeepalive
; /*!< Send RTP comfort noice packets for keepalive */
139 /* DTMF Reception Variables */
141 unsigned int lastevent
;
143 unsigned int dtmfsamples
;
144 /* DTMF Transmission Variables */
145 unsigned int lastdigitts
;
146 char sending_digit
; /*!< boolean - are we sending digits */
147 char send_digit
; /*!< digit we are sending */
152 struct sockaddr_in us
; /*!< Socket representation of the local endpoint. */
153 struct sockaddr_in them
; /*!< Socket representation of the remote endpoint. */
154 struct timeval rxcore
;
155 struct timeval txcore
;
156 double drxcore
; /*!< The double representation of the first received packet */
157 struct timeval lastrx
; /*!< timeval when we last received a packet */
158 struct timeval dtmfmute
;
159 struct ast_smoother
*smoother
;
161 unsigned short seqno
; /*!< Sequence number, RFC 3550, page 13. */
162 unsigned short rxseqno
;
163 struct sched_context
*sched
;
164 struct io_context
*io
;
166 ast_rtp_callback callback
;
167 ast_mutex_t bridge_lock
;
168 struct rtpPayloadType current_RTP_PT
[MAX_RTP_PT
];
169 int rtp_lookup_code_cache_isAstFormat
; /*!< a cache for the result of rtp_lookup_code(): */
170 int rtp_lookup_code_cache_code
;
171 int rtp_lookup_code_cache_result
;
172 struct ast_rtcp
*rtcp
;
173 struct ast_codec_pref pref
;
174 struct ast_rtp
*bridged
; /*!< Who we are Packet bridged to */
175 int set_marker_bit
:1; /*!< Whether to set the marker bit or not */
178 /* Forward declarations */
179 static int ast_rtcp_write(const void *data
);
180 static void timeval2ntp(struct timeval tv
, unsigned int *msw
, unsigned int *lsw
);
181 static int ast_rtcp_write_sr(const void *data
);
182 static int ast_rtcp_write_rr(const void *data
);
183 static unsigned int ast_rtcp_calc_interval(struct ast_rtp
*rtp
);
184 static int ast_rtp_senddigit_continuation(struct ast_rtp
*rtp
);
185 int ast_rtp_senddigit_end(struct ast_rtp
*rtp
, char digit
);
187 #define FLAG_3389_WARNING (1 << 0)
188 #define FLAG_NAT_ACTIVE (3 << 1)
189 #define FLAG_NAT_INACTIVE (0 << 1)
190 #define FLAG_NAT_INACTIVE_NOWARN (1 << 1)
191 #define FLAG_HAS_DTMF (1 << 3)
192 #define FLAG_P2P_SENT_MARK (1 << 4)
193 #define FLAG_P2P_NEED_DTMF (1 << 5)
194 #define FLAG_CALLBACK_MODE (1 << 6)
195 #define FLAG_DTMF_COMPENSATE (1 << 7)
196 #define FLAG_HAS_STUN (1 << 8)
199 * \brief Structure defining an RTCP session.
201 * The concept "RTCP session" is not defined in RFC 3550, but since
202 * this structure is analogous to ast_rtp, which tracks a RTP session,
203 * it is logical to think of this as a RTCP session.
205 * RTCP packet is defined on page 9 of RFC 3550.
209 int s
; /*!< Socket */
210 struct sockaddr_in us
; /*!< Socket representation of the local endpoint. */
211 struct sockaddr_in them
; /*!< Socket representation of the remote endpoint. */
212 unsigned int soc
; /*!< What they told us */
213 unsigned int spc
; /*!< What they told us */
214 unsigned int themrxlsr
; /*!< The middle 32 bits of the NTP timestamp in the last received SR*/
215 struct timeval rxlsr
; /*!< Time when we got their last SR */
216 struct timeval txlsr
; /*!< Time when we sent or last SR*/
217 unsigned int expected_prior
; /*!< no. packets in previous interval */
218 unsigned int received_prior
; /*!< no. packets received in previous interval */
219 int schedid
; /*!< Schedid returned from ast_sched_add() to schedule RTCP-transmissions*/
220 unsigned int rr_count
; /*!< number of RRs we've sent, not including report blocks in SR's */
221 unsigned int sr_count
; /*!< number of SRs we've sent */
222 unsigned int lastsrtxcount
; /*!< Transmit packet count when last SR sent */
223 double accumulated_transit
; /*!< accumulated a-dlsr-lsr */
224 double rtt
; /*!< Last reported rtt */
225 unsigned int reported_jitter
; /*!< The contents of their last jitter entry in the RR */
226 unsigned int reported_lost
; /*!< Reported lost packets in their RR */
227 char quality
[AST_MAX_USER_FIELD
];
236 typedef struct { unsigned int id
[4]; } __attribute__((packed
)) stun_trans_id
;
238 /* XXX Maybe stun belongs in another file if it ever has use outside of RTP */
240 unsigned short msgtype
;
241 unsigned short msglen
;
243 unsigned char ies
[0];
244 } __attribute__((packed
));
249 unsigned char value
[0];
250 } __attribute__((packed
));
253 unsigned char unused
;
254 unsigned char family
;
257 } __attribute__((packed
));
259 #define STUN_IGNORE (0)
260 #define STUN_ACCEPT (1)
262 #define STUN_BINDREQ 0x0001
263 #define STUN_BINDRESP 0x0101
264 #define STUN_BINDERR 0x0111
265 #define STUN_SECREQ 0x0002
266 #define STUN_SECRESP 0x0102
267 #define STUN_SECERR 0x0112
269 #define STUN_MAPPED_ADDRESS 0x0001
270 #define STUN_RESPONSE_ADDRESS 0x0002
271 #define STUN_CHANGE_REQUEST 0x0003
272 #define STUN_SOURCE_ADDRESS 0x0004
273 #define STUN_CHANGED_ADDRESS 0x0005
274 #define STUN_USERNAME 0x0006
275 #define STUN_PASSWORD 0x0007
276 #define STUN_MESSAGE_INTEGRITY 0x0008
277 #define STUN_ERROR_CODE 0x0009
278 #define STUN_UNKNOWN_ATTRIBUTES 0x000a
279 #define STUN_REFLECTED_FROM 0x000b
281 static const char *stun_msg2str(int msg
)
285 return "Binding Request";
287 return "Binding Response";
289 return "Binding Error Response";
291 return "Shared Secret Request";
293 return "Shared Secret Response";
295 return "Shared Secret Error Response";
297 return "Non-RFC3489 Message";
300 static const char *stun_attr2str(int msg
)
303 case STUN_MAPPED_ADDRESS
:
304 return "Mapped Address";
305 case STUN_RESPONSE_ADDRESS
:
306 return "Response Address";
307 case STUN_CHANGE_REQUEST
:
308 return "Change Request";
309 case STUN_SOURCE_ADDRESS
:
310 return "Source Address";
311 case STUN_CHANGED_ADDRESS
:
312 return "Changed Address";
317 case STUN_MESSAGE_INTEGRITY
:
318 return "Message Integrity";
319 case STUN_ERROR_CODE
:
321 case STUN_UNKNOWN_ATTRIBUTES
:
322 return "Unknown Attributes";
323 case STUN_REFLECTED_FROM
:
324 return "Reflected From";
326 return "Non-RFC3489 Attribute";
330 const char *username
;
331 const char *password
;
334 static int stun_process_attr(struct stun_state
*state
, struct stun_attr
*attr
)
337 ast_verbose("Found STUN Attribute %s (%04x), length %d\n",
338 stun_attr2str(ntohs(attr
->attr
)), ntohs(attr
->attr
), ntohs(attr
->len
));
339 switch(ntohs(attr
->attr
)) {
341 state
->username
= (const char *) (attr
->value
);
344 state
->password
= (const char *) (attr
->value
);
348 ast_verbose("Ignoring STUN attribute %s (%04x), length %d\n",
349 stun_attr2str(ntohs(attr
->attr
)), ntohs(attr
->attr
), ntohs(attr
->len
));
354 static void append_attr_string(struct stun_attr
**attr
, int attrval
, const char *s
, int *len
, int *left
)
356 int size
= sizeof(**attr
) + strlen(s
);
358 (*attr
)->attr
= htons(attrval
);
359 (*attr
)->len
= htons(strlen(s
));
360 memcpy((*attr
)->value
, s
, strlen(s
));
361 (*attr
) = (struct stun_attr
*)((*attr
)->value
+ strlen(s
));
367 static void append_attr_address(struct stun_attr
**attr
, int attrval
, struct sockaddr_in
*sin
, int *len
, int *left
)
369 int size
= sizeof(**attr
) + 8;
370 struct stun_addr
*addr
;
372 (*attr
)->attr
= htons(attrval
);
373 (*attr
)->len
= htons(8);
374 addr
= (struct stun_addr
*)((*attr
)->value
);
377 addr
->port
= sin
->sin_port
;
378 addr
->addr
= sin
->sin_addr
.s_addr
;
379 (*attr
) = (struct stun_attr
*)((*attr
)->value
+ 8);
385 static int stun_send(int s
, struct sockaddr_in
*dst
, struct stun_header
*resp
)
387 return sendto(s
, resp
, ntohs(resp
->msglen
) + sizeof(*resp
), 0,
388 (struct sockaddr
*)dst
, sizeof(*dst
));
391 static void stun_req_id(struct stun_header
*req
)
395 req
->id
.id
[x
] = ast_random();
398 size_t ast_rtp_alloc_size(void)
400 return sizeof(struct ast_rtp
);
403 void ast_rtp_stun_request(struct ast_rtp
*rtp
, struct sockaddr_in
*suggestion
, const char *username
)
405 struct stun_header
*req
;
406 unsigned char reqdata
[1024];
408 struct stun_attr
*attr
;
410 req
= (struct stun_header
*)reqdata
;
413 reqleft
= sizeof(reqdata
) - sizeof(struct stun_header
);
416 attr
= (struct stun_attr
*)req
->ies
;
418 append_attr_string(&attr
, STUN_USERNAME
, username
, &reqlen
, &reqleft
);
419 req
->msglen
= htons(reqlen
);
420 req
->msgtype
= htons(STUN_BINDREQ
);
421 stun_send(rtp
->s
, suggestion
, req
);
424 static int stun_handle_packet(int s
, struct sockaddr_in
*src
, unsigned char *data
, size_t len
)
426 struct stun_header
*resp
, *hdr
= (struct stun_header
*)data
;
427 struct stun_attr
*attr
;
428 struct stun_state st
;
429 int ret
= STUN_IGNORE
;
430 unsigned char respdata
[1024];
431 int resplen
, respleft
;
433 if (len
< sizeof(struct stun_header
)) {
435 ast_log(LOG_DEBUG
, "Runt STUN packet (only %zd, wanting at least %zd)\n", len
, sizeof(struct stun_header
));
439 ast_verbose("STUN Packet, msg %s (%04x), length: %d\n", stun_msg2str(ntohs(hdr
->msgtype
)), ntohs(hdr
->msgtype
), ntohs(hdr
->msglen
));
440 if (ntohs(hdr
->msglen
) > len
- sizeof(struct stun_header
)) {
442 ast_log(LOG_DEBUG
, "Scrambled STUN packet length (got %d, expecting %zd)\n", ntohs(hdr
->msglen
), len
- sizeof(struct stun_header
));
444 len
= ntohs(hdr
->msglen
);
445 data
+= sizeof(struct stun_header
);
446 memset(&st
, 0, sizeof(st
));
448 if (len
< sizeof(struct stun_attr
)) {
450 ast_log(LOG_DEBUG
, "Runt Attribute (got %zd, expecting %zd)\n", len
, sizeof(struct stun_attr
));
453 attr
= (struct stun_attr
*)data
;
454 if ((ntohs(attr
->len
) + sizeof(struct stun_attr
)) > len
) {
456 ast_log(LOG_DEBUG
, "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", (int) (ntohs(attr
->len
) + sizeof(struct stun_attr
)), (int) len
);
459 if (stun_process_attr(&st
, attr
)) {
461 ast_log(LOG_DEBUG
, "Failed to handle attribute %s (%04x)\n", stun_attr2str(ntohs(attr
->attr
)), ntohs(attr
->attr
));
464 /* Clear attribute in case previous entry was a string */
466 data
+= ntohs(attr
->len
) + sizeof(struct stun_attr
);
467 len
-= ntohs(attr
->len
) + sizeof(struct stun_attr
);
469 /* Null terminate any string */
471 resp
= (struct stun_header
*)respdata
;
473 respleft
= sizeof(respdata
) - sizeof(struct stun_header
);
477 attr
= (struct stun_attr
*)resp
->ies
;
479 switch(ntohs(hdr
->msgtype
)) {
482 ast_verbose("STUN Bind Request, username: %s\n",
483 st
.username
? st
.username
: "<none>");
485 append_attr_string(&attr
, STUN_USERNAME
, st
.username
, &resplen
, &respleft
);
486 append_attr_address(&attr
, STUN_MAPPED_ADDRESS
, src
, &resplen
, &respleft
);
487 resp
->msglen
= htons(resplen
);
488 resp
->msgtype
= htons(STUN_BINDRESP
);
489 stun_send(s
, src
, resp
);
494 ast_verbose("Dunno what to do with STUN message %04x (%s)\n", ntohs(hdr
->msgtype
), stun_msg2str(ntohs(hdr
->msgtype
)));
500 /*! \brief List of current sessions */
501 static AST_LIST_HEAD_STATIC(protos
, ast_rtp_protocol
);
503 static void timeval2ntp(struct timeval tv
, unsigned int *msw
, unsigned int *lsw
)
505 unsigned int sec
, usec
, frac
;
506 sec
= tv
.tv_sec
+ 2208988800u; /* Sec between 1900 and 1970 */
508 frac
= (usec
<< 12) + (usec
<< 8) - ((usec
* 3650) >> 6);
513 int ast_rtp_fd(struct ast_rtp
*rtp
)
518 int ast_rtcp_fd(struct ast_rtp
*rtp
)
525 unsigned int ast_rtcp_calc_interval(struct ast_rtp
*rtp
)
527 unsigned int interval
;
528 /*! \todo XXX Do a more reasonable calculation on this one
529 * Look in RFC 3550 Section A.7 for an example*/
530 interval
= rtcpinterval
;
534 /* \brief Put RTP timeout timers on hold during another transaction, like T.38 */
535 void ast_rtp_set_rtptimers_onhold(struct ast_rtp
*rtp
)
537 rtp
->rtptimeout
= (-1) * rtp
->rtptimeout
;
538 rtp
->rtpholdtimeout
= (-1) * rtp
->rtpholdtimeout
;
541 /*! \brief Set rtp timeout */
542 void ast_rtp_set_rtptimeout(struct ast_rtp
*rtp
, int timeout
)
544 rtp
->rtptimeout
= timeout
;
547 /*! \brief Set rtp hold timeout */
548 void ast_rtp_set_rtpholdtimeout(struct ast_rtp
*rtp
, int timeout
)
550 rtp
->rtpholdtimeout
= timeout
;
553 /*! \brief set RTP keepalive interval */
554 void ast_rtp_set_rtpkeepalive(struct ast_rtp
*rtp
, int period
)
556 rtp
->rtpkeepalive
= period
;
559 /*! \brief Get rtp timeout */
560 int ast_rtp_get_rtptimeout(struct ast_rtp
*rtp
)
562 if (rtp
->rtptimeout
< 0) /* We're not checking, but remembering the setting (during T.38 transmission) */
564 return rtp
->rtptimeout
;
567 /*! \brief Get rtp hold timeout */
568 int ast_rtp_get_rtpholdtimeout(struct ast_rtp
*rtp
)
570 if (rtp
->rtptimeout
< 0) /* We're not checking, but remembering the setting (during T.38 transmission) */
572 return rtp
->rtpholdtimeout
;
575 /*! \brief Get RTP keepalive interval */
576 int ast_rtp_get_rtpkeepalive(struct ast_rtp
*rtp
)
578 return rtp
->rtpkeepalive
;
581 void ast_rtp_set_data(struct ast_rtp
*rtp
, void *data
)
586 void ast_rtp_set_callback(struct ast_rtp
*rtp
, ast_rtp_callback callback
)
588 rtp
->callback
= callback
;
591 void ast_rtp_setnat(struct ast_rtp
*rtp
, int nat
)
596 int ast_rtp_getnat(struct ast_rtp
*rtp
)
598 return ast_test_flag(rtp
, FLAG_NAT_ACTIVE
);
601 void ast_rtp_setdtmf(struct ast_rtp
*rtp
, int dtmf
)
603 ast_set2_flag(rtp
, dtmf
? 1 : 0, FLAG_HAS_DTMF
);
606 void ast_rtp_setdtmfcompensate(struct ast_rtp
*rtp
, int compensate
)
608 ast_set2_flag(rtp
, compensate
? 1 : 0, FLAG_DTMF_COMPENSATE
);
611 void ast_rtp_setstun(struct ast_rtp
*rtp
, int stun_enable
)
613 ast_set2_flag(rtp
, stun_enable
? 1 : 0, FLAG_HAS_STUN
);
616 static struct ast_frame
*send_dtmf(struct ast_rtp
*rtp
, enum ast_frame_type type
)
618 if (((ast_test_flag(rtp
, FLAG_DTMF_COMPENSATE
) && type
== AST_FRAME_DTMF_END
) ||
619 (type
== AST_FRAME_DTMF_BEGIN
)) && ast_tvcmp(ast_tvnow(), rtp
->dtmfmute
) < 0) {
621 ast_log(LOG_DEBUG
, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(rtp
->them
.sin_addr
));
623 rtp
->dtmfsamples
= 0;
624 return &ast_null_frame
;
627 ast_log(LOG_DEBUG
, "Sending dtmf: %d (%c), at %s\n", rtp
->resp
, rtp
->resp
, ast_inet_ntoa(rtp
->them
.sin_addr
));
628 if (rtp
->resp
== 'X') {
629 rtp
->f
.frametype
= AST_FRAME_CONTROL
;
630 rtp
->f
.subclass
= AST_CONTROL_FLASH
;
632 rtp
->f
.frametype
= type
;
633 rtp
->f
.subclass
= rtp
->resp
;
643 static inline int rtp_debug_test_addr(struct sockaddr_in
*addr
)
647 if (rtpdebugaddr
.sin_addr
.s_addr
) {
648 if (((ntohs(rtpdebugaddr
.sin_port
) != 0)
649 && (rtpdebugaddr
.sin_port
!= addr
->sin_port
))
650 || (rtpdebugaddr
.sin_addr
.s_addr
!= addr
->sin_addr
.s_addr
))
656 static inline int rtcp_debug_test_addr(struct sockaddr_in
*addr
)
660 if (rtcpdebugaddr
.sin_addr
.s_addr
) {
661 if (((ntohs(rtcpdebugaddr
.sin_port
) != 0)
662 && (rtcpdebugaddr
.sin_port
!= addr
->sin_port
))
663 || (rtcpdebugaddr
.sin_addr
.s_addr
!= addr
->sin_addr
.s_addr
))
670 static struct ast_frame
*process_cisco_dtmf(struct ast_rtp
*rtp
, unsigned char *data
, int len
)
674 struct ast_frame
*f
= NULL
;
675 event
= ntohl(*((unsigned int *)(data
)));
677 if (option_debug
> 2 || rtpdebug
)
678 ast_log(LOG_DEBUG
, "Cisco DTMF Digit: %08x (len = %d)\n", event
, len
);
681 } else if (event
< 11) {
683 } else if (event
< 12) {
685 } else if (event
< 16) {
686 resp
= 'A' + (event
- 12);
687 } else if (event
< 17) {
690 if (rtp
->resp
&& (rtp
->resp
!= resp
)) {
691 f
= send_dtmf(rtp
, AST_FRAME_DTMF_END
);
694 rtp
->dtmfcount
= dtmftimeout
;
699 * \brief Process RTP DTMF and events according to RFC 2833.
701 * RFC 2833 is "RTP Payload for DTMF Digits, Telephony Tones and Telephony Signals".
709 static struct ast_frame
*process_rfc2833(struct ast_rtp
*rtp
, unsigned char *data
, int len
, unsigned int seqno
, unsigned int timestamp
)
712 unsigned int event_end
;
713 unsigned int samples
;
715 struct ast_frame
*f
= NULL
;
717 /* Figure out event, event end, and samples */
718 event
= ntohl(*((unsigned int *)(data
)));
720 event_end
= ntohl(*((unsigned int *)(data
)));
723 samples
= ntohl(*((unsigned int *)(data
)));
726 /* Print out debug if turned on */
727 if (rtpdebug
|| option_debug
> 2)
728 ast_log(LOG_DEBUG
, "- RTP 2833 Event: %08x (len = %d)\n", event
, len
);
730 /* Figure out what digit was pressed */
733 } else if (event
< 11) {
735 } else if (event
< 12) {
737 } else if (event
< 16) {
738 resp
= 'A' + (event
- 12);
739 } else if (event
< 17) { /* Event 16: Hook flash */
742 /* Not a supported event */
743 ast_log(LOG_DEBUG
, "Ignoring RTP 2833 Event: %08x. Not a DTMF Digit.\n", event
);
744 return &ast_null_frame
;
747 if (ast_test_flag(rtp
, FLAG_DTMF_COMPENSATE
)) {
748 if ((rtp
->lastevent
!= timestamp
) || (rtp
->resp
&& rtp
->resp
!= resp
)) {
750 f
= send_dtmf(rtp
, AST_FRAME_DTMF_END
);
752 rtp
->lastevent
= timestamp
;
755 if ((!(rtp
->resp
) && (!(event_end
& 0x80))) || (rtp
->resp
&& rtp
->resp
!= resp
)) {
757 f
= send_dtmf(rtp
, AST_FRAME_DTMF_BEGIN
);
758 } else if ((event_end
& 0x80) && (rtp
->lastevent
!= seqno
) && rtp
->resp
) {
759 f
= send_dtmf(rtp
, AST_FRAME_DTMF_END
);
760 f
->len
= ast_tvdiff_ms(ast_samp2tv(samples
, 8000), ast_tv(0, 0)); /* XXX hard coded 8kHz */
762 rtp
->lastevent
= seqno
;
766 rtp
->dtmfcount
= dtmftimeout
;
767 rtp
->dtmfsamples
= samples
;
773 * \brief Process Comfort Noise RTP.
775 * This is incomplete at the moment.
778 static struct ast_frame
*process_rfc3389(struct ast_rtp
*rtp
, unsigned char *data
, int len
)
780 struct ast_frame
*f
= NULL
;
781 /* Convert comfort noise into audio with various codecs. Unfortunately this doesn't
782 totally help us out becuase we don't have an engine to keep it going and we are not
783 guaranteed to have it every 20ms or anything */
785 ast_log(LOG_DEBUG
, "- RTP 3389 Comfort noise event: Level %d (len = %d)\n", rtp
->lastrxformat
, len
);
787 if (!(ast_test_flag(rtp
, FLAG_3389_WARNING
))) {
788 ast_log(LOG_NOTICE
, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client IP: %s\n",
789 ast_inet_ntoa(rtp
->them
.sin_addr
));
790 ast_set_flag(rtp
, FLAG_3389_WARNING
);
793 /* Must have at least one byte */
797 rtp
->f
.data
= rtp
->rawdata
+ AST_FRIENDLY_OFFSET
;
798 rtp
->f
.datalen
= len
- 1;
799 rtp
->f
.offset
= AST_FRIENDLY_OFFSET
;
800 memcpy(rtp
->f
.data
, data
+ 1, len
- 1);
806 rtp
->f
.frametype
= AST_FRAME_CNG
;
807 rtp
->f
.subclass
= data
[0] & 0x7f;
808 rtp
->f
.datalen
= len
- 1;
810 rtp
->f
.delivery
.tv_usec
= rtp
->f
.delivery
.tv_sec
= 0;
815 static int rtpread(int *id
, int fd
, short events
, void *cbdata
)
817 struct ast_rtp
*rtp
= cbdata
;
819 f
= ast_rtp_read(rtp
);
822 rtp
->callback(rtp
, f
, rtp
->data
);
827 struct ast_frame
*ast_rtcp_read(struct ast_rtp
*rtp
)
830 int position
, i
, packetwords
;
832 struct sockaddr_in sin
;
833 unsigned int rtcpdata
[8192 + AST_FRIENDLY_OFFSET
];
834 unsigned int *rtcpheader
;
846 struct ast_frame
*f
= &ast_null_frame
;
848 if (!rtp
|| !rtp
->rtcp
)
849 return &ast_null_frame
;
853 res
= recvfrom(rtp
->rtcp
->s
, rtcpdata
+ AST_FRIENDLY_OFFSET
, sizeof(rtcpdata
) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET
,
854 0, (struct sockaddr
*)&sin
, &len
);
855 rtcpheader
= (unsigned int *)(rtcpdata
+ AST_FRIENDLY_OFFSET
);
860 if (errno
!= EAGAIN
) {
861 ast_log(LOG_WARNING
, "RTCP Read error: %s. Hanging up.\n", strerror(errno
));
864 return &ast_null_frame
;
867 packetwords
= res
/ 4;
870 /* Send to whoever sent to us */
871 if ((rtp
->rtcp
->them
.sin_addr
.s_addr
!= sin
.sin_addr
.s_addr
) ||
872 (rtp
->rtcp
->them
.sin_port
!= sin
.sin_port
)) {
873 memcpy(&rtp
->rtcp
->them
, &sin
, sizeof(rtp
->rtcp
->them
));
874 if (option_debug
|| rtpdebug
)
875 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
));
880 ast_log(LOG_DEBUG
, "Got RTCP report of %d bytes\n", res
);
882 /* Process a compound packet */
884 while (position
< packetwords
) {
886 length
= ntohl(rtcpheader
[i
]);
887 pt
= (length
& 0xff0000) >> 16;
888 rc
= (length
& 0x1f000000) >> 24;
891 if ((i
+ length
) > packetwords
) {
892 ast_log(LOG_WARNING
, "RTCP Read too short\n");
893 return &ast_null_frame
;
896 if (rtcp_debug_test_addr(&sin
)) {
897 ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin
.sin_addr
), ntohs(sin
.sin_port
));
898 ast_verbose("PT: %d(%s)\n", pt
, (pt
== 200) ? "Sender Report" : (pt
== 201) ? "Receiver Report" : (pt
== 192) ? "H.261 FUR" : "Unknown");
899 ast_verbose("Reception reports: %d\n", rc
);
900 ast_verbose("SSRC of sender: %u\n", rtcpheader
[i
+ 1]);
903 i
+= 2; /* Advance past header and ssrc */
907 gettimeofday(&rtp
->rtcp
->rxlsr
,NULL
); /* To be able to populate the dlsr */
908 rtp
->rtcp
->spc
= ntohl(rtcpheader
[i
+3]);
909 rtp
->rtcp
->soc
= ntohl(rtcpheader
[i
+ 4]);
910 rtp
->rtcp
->themrxlsr
= ((ntohl(rtcpheader
[i
]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader
[i
+ 1]) & 0xffff0000) >> 16); /* Going to LSR in RR*/
912 if (rtcp_debug_test_addr(&sin
)) {
913 ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader
[i
]), (unsigned long) ntohl(rtcpheader
[i
+ 1]) * 4096);
914 ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader
[i
+ 2]));
915 ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader
[i
+ 3]), (unsigned long) ntohl(rtcpheader
[i
+ 4]));
920 /* Intentional fall through */
922 /* Don't handle multiple reception reports (rc > 1) yet */
923 /* Calculate RTT per RFC */
924 gettimeofday(&now
, NULL
);
925 timeval2ntp(now
, &msw
, &lsw
);
926 if (ntohl(rtcpheader
[i
+ 4]) && ntohl(rtcpheader
[i
+ 5])) { /* We must have the LSR && DLSR */
927 comp
= ((msw
& 0xffff) << 16) | ((lsw
& 0xffff0000) >> 16);
928 lsr
= ntohl(rtcpheader
[i
+ 4]);
929 dlsr
= ntohl(rtcpheader
[i
+ 5]);
930 rtt
= comp
- lsr
- dlsr
;
932 /* Convert end to end delay to usec (keeping the calculation in 64bit space)
933 sess->ee_delay = (eedelay * 1000) / 65536; */
935 rtt
= (rtt
* 1000000) >> 16;
937 rtt
= (rtt
* 1000) >> 16;
941 rttsec
= rtt
/ 1000.;
943 if (comp
- dlsr
>= lsr
) {
944 rtp
->rtcp
->accumulated_transit
+= rttsec
;
945 rtp
->rtcp
->rtt
= rttsec
;
946 if (rtp
->rtcp
->maxrtt
<rttsec
)
947 rtp
->rtcp
->maxrtt
= rttsec
;
948 if (rtp
->rtcp
->minrtt
>rttsec
)
949 rtp
->rtcp
->minrtt
= rttsec
;
950 } else if (rtcp_debug_test_addr(&sin
)) {
951 ast_verbose("Internal RTCP NTP clock skew detected: "
952 "lsr=%u, now=%u, dlsr=%u (%d:%03dms), "
954 lsr
, comp
, dlsr
, dlsr
/ 65536,
955 (dlsr
% 65536) * 1000 / 65536,
956 dlsr
- (comp
- lsr
));
960 rtp
->rtcp
->reported_jitter
= ntohl(rtcpheader
[i
+ 3]);
961 rtp
->rtcp
->reported_lost
= ntohl(rtcpheader
[i
+ 1]) & 0xffffff;
962 if (rtcp_debug_test_addr(&sin
)) {
963 ast_verbose(" Fraction lost: %ld\n", (((long) ntohl(rtcpheader
[i
+ 1]) & 0xff000000) >> 24));
964 ast_verbose(" Packets lost so far: %d\n", rtp
->rtcp
->reported_lost
);
965 ast_verbose(" Highest sequence number: %ld\n", (long) (ntohl(rtcpheader
[i
+ 2]) & 0xffff));
966 ast_verbose(" Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader
[i
+ 2]) & 0xffff) >> 16);
967 ast_verbose(" Interarrival jitter: %u\n", rtp
->rtcp
->reported_jitter
);
968 ast_verbose(" Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader
[i
+ 4]) >> 16,((unsigned long) ntohl(rtcpheader
[i
+ 4]) << 16) * 4096);
969 ast_verbose(" DLSR: %4.4f (sec)\n",ntohl(rtcpheader
[i
+ 5])/65536.0);
971 ast_verbose(" RTT: %lu(sec)\n", (unsigned long) rtt
);
975 if (rtcp_debug_test_addr(&sin
))
976 ast_verbose("Received an RTCP Fast Update Request\n");
977 rtp
->f
.frametype
= AST_FRAME_CONTROL
;
978 rtp
->f
.subclass
= AST_CONTROL_VIDUPDATE
;
986 if (rtcp_debug_test_addr(&sin
))
987 ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp
->rtcp
->them
.sin_addr
), ntohs(rtp
->rtcp
->them
.sin_port
));
990 if (rtcp_debug_test_addr(&sin
))
991 ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp
->rtcp
->them
.sin_addr
), ntohs(rtp
->rtcp
->them
.sin_port
));
995 ast_log(LOG_DEBUG
, "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
));
998 position
+= (length
+ 1);
1004 static void calc_rxstamp(struct timeval
*tv
, struct ast_rtp
*rtp
, unsigned int timestamp
, int mark
)
1008 double current_time
;
1013 if ((!rtp
->rxcore
.tv_sec
&& !rtp
->rxcore
.tv_usec
) || mark
) {
1014 gettimeofday(&rtp
->rxcore
, NULL
);
1015 rtp
->drxcore
= (double) rtp
->rxcore
.tv_sec
+ (double) rtp
->rxcore
.tv_usec
/ 1000000;
1016 /* map timestamp to a real time */
1017 rtp
->seedrxts
= timestamp
; /* Their RTP timestamp started with this */
1018 rtp
->rxcore
.tv_sec
-= timestamp
/ 8000;
1019 rtp
->rxcore
.tv_usec
-= (timestamp
% 8000) * 125;
1020 /* Round to 0.1ms for nice, pretty timestamps */
1021 rtp
->rxcore
.tv_usec
-= rtp
->rxcore
.tv_usec
% 100;
1022 if (rtp
->rxcore
.tv_usec
< 0) {
1023 /* Adjust appropriately if necessary */
1024 rtp
->rxcore
.tv_usec
+= 1000000;
1025 rtp
->rxcore
.tv_sec
-= 1;
1029 gettimeofday(&now
,NULL
);
1030 /* rxcore is the mapping between the RTP timestamp and _our_ real time from gettimeofday() */
1031 tv
->tv_sec
= rtp
->rxcore
.tv_sec
+ timestamp
/ 8000;
1032 tv
->tv_usec
= rtp
->rxcore
.tv_usec
+ (timestamp
% 8000) * 125;
1033 if (tv
->tv_usec
>= 1000000) {
1034 tv
->tv_usec
-= 1000000;
1037 prog
= (double)((timestamp
-rtp
->seedrxts
)/8000.);
1038 dtv
= (double)rtp
->drxcore
+ (double)(prog
);
1039 current_time
= (double)now
.tv_sec
+ (double)now
.tv_usec
/1000000;
1040 transit
= current_time
- dtv
;
1041 d
= transit
- rtp
->rxtransit
;
1042 rtp
->rxtransit
= transit
;
1045 rtp
->rxjitter
+= (1./16.) * (d
- rtp
->rxjitter
);
1046 if (rtp
->rtcp
&& rtp
->rxjitter
> rtp
->rtcp
->maxrxjitter
)
1047 rtp
->rtcp
->maxrxjitter
= rtp
->rxjitter
;
1048 if (rtp
->rtcp
&& rtp
->rxjitter
< rtp
->rtcp
->minrxjitter
)
1049 rtp
->rtcp
->minrxjitter
= rtp
->rxjitter
;
1052 /*! \brief Perform a Packet2Packet RTP write */
1053 static int bridge_p2p_rtp_write(struct ast_rtp
*rtp
, struct ast_rtp
*bridged
, unsigned int *rtpheader
, int len
, int hdrlen
)
1055 int res
= 0, payload
= 0, bridged_payload
= 0, mark
;
1056 struct rtpPayloadType rtpPT
;
1057 int reconstruct
= ntohl(rtpheader
[0]);
1059 /* Get fields from packet */
1060 payload
= (reconstruct
& 0x7f0000) >> 16;
1061 mark
= (((reconstruct
& 0x800000) >> 23) != 0);
1063 /* Check what the payload value should be */
1064 rtpPT
= ast_rtp_lookup_pt(rtp
, payload
);
1066 /* If the payload coming in is not one of the negotiated ones then send it to the core, this will cause formats to change and the bridge to break */
1067 if (!bridged
->current_RTP_PT
[payload
].code
)
1070 /* If the payload is DTMF, and we are listening for DTMF - then feed it into the core */
1071 if (ast_test_flag(rtp
, FLAG_P2P_NEED_DTMF
) && !rtpPT
.isAstFormat
&& rtpPT
.code
== AST_RTP_DTMF
)
1074 /* Otherwise adjust bridged payload to match */
1075 bridged_payload
= ast_rtp_lookup_code(bridged
, rtpPT
.isAstFormat
, rtpPT
.code
);
1077 /* If the mark bit has not been sent yet... do it now */
1078 if (!ast_test_flag(rtp
, FLAG_P2P_SENT_MARK
)) {
1080 ast_set_flag(rtp
, FLAG_P2P_SENT_MARK
);
1083 /* Reconstruct part of the packet */
1084 reconstruct
&= 0xFF80FFFF;
1085 reconstruct
|= (bridged_payload
<< 16);
1086 reconstruct
|= (mark
<< 23);
1087 rtpheader
[0] = htonl(reconstruct
);
1089 /* Send the packet back out */
1090 res
= sendto(bridged
->s
, (void *)rtpheader
, len
, 0, (struct sockaddr
*)&bridged
->them
, sizeof(bridged
->them
));
1092 if (!bridged
->nat
|| (bridged
->nat
&& (ast_test_flag(bridged
, FLAG_NAT_ACTIVE
) == FLAG_NAT_ACTIVE
))) {
1093 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
));
1094 } else if (((ast_test_flag(bridged
, FLAG_NAT_ACTIVE
) == FLAG_NAT_INACTIVE
) || rtpdebug
) && !ast_test_flag(bridged
, FLAG_NAT_INACTIVE_NOWARN
)) {
1095 if (option_debug
|| rtpdebug
)
1096 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
));
1097 ast_set_flag(bridged
, FLAG_NAT_INACTIVE_NOWARN
);
1100 } else if (rtp_debug_test_addr(&bridged
->them
))
1101 ast_verbose("Sent RTP P2P packet to %s:%u (type %-2.2d, len %-6.6u)\n", ast_inet_ntoa(bridged
->them
.sin_addr
), ntohs(bridged
->them
.sin_port
), bridged_payload
, len
- hdrlen
);
1106 struct ast_frame
*ast_rtp_read(struct ast_rtp
*rtp
)
1109 struct sockaddr_in sin
;
1120 unsigned int timestamp
;
1121 unsigned int *rtpheader
;
1122 struct rtpPayloadType rtpPT
;
1123 struct ast_rtp
*bridged
= NULL
;
1125 /* If time is up, kill it */
1126 if (rtp
->sending_digit
)
1127 ast_rtp_senddigit_continuation(rtp
);
1131 /* Cache where the header will go */
1132 res
= recvfrom(rtp
->s
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
, sizeof(rtp
->rawdata
) - AST_FRIENDLY_OFFSET
,
1133 0, (struct sockaddr
*)&sin
, &len
);
1135 rtpheader
= (unsigned int *)(rtp
->rawdata
+ AST_FRIENDLY_OFFSET
);
1139 if (errno
!= EAGAIN
) {
1140 ast_log(LOG_WARNING
, "RTP Read error: %s. Hanging up.\n", strerror(errno
));
1143 return &ast_null_frame
;
1147 ast_log(LOG_WARNING
, "RTP Read too short\n");
1148 return &ast_null_frame
;
1152 seqno
= ntohl(rtpheader
[0]);
1154 /* Check RTP version */
1155 version
= (seqno
& 0xC0000000) >> 30;
1157 if ((stun_handle_packet(rtp
->s
, &sin
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
, res
) == STUN_ACCEPT
) &&
1158 (!rtp
->them
.sin_port
&& !rtp
->them
.sin_addr
.s_addr
)) {
1159 memcpy(&rtp
->them
, &sin
, sizeof(rtp
->them
));
1161 return &ast_null_frame
;
1164 #if 0 /* Allow to receive RTP stream with closed transmission path */
1165 /* If we don't have the other side's address, then ignore this */
1166 if (!rtp
->them
.sin_addr
.s_addr
|| !rtp
->them
.sin_port
)
1167 return &ast_null_frame
;
1170 /* Send to whoever send to us if NAT is turned on */
1172 if ((rtp
->them
.sin_addr
.s_addr
!= sin
.sin_addr
.s_addr
) ||
1173 (rtp
->them
.sin_port
!= sin
.sin_port
)) {
1176 memcpy(&rtp
->rtcp
->them
, &sin
, sizeof(rtp
->rtcp
->them
));
1177 rtp
->rtcp
->them
.sin_port
= htons(ntohs(rtp
->them
.sin_port
)+1);
1180 ast_set_flag(rtp
, FLAG_NAT_ACTIVE
);
1181 if (option_debug
|| rtpdebug
)
1182 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
));
1186 /* If we are bridged to another RTP stream, send direct */
1187 if ((bridged
= ast_rtp_get_bridged(rtp
)) && !bridge_p2p_rtp_write(rtp
, bridged
, rtpheader
, res
, hdrlen
))
1188 return &ast_null_frame
;
1191 return &ast_null_frame
;
1193 payloadtype
= (seqno
& 0x7f0000) >> 16;
1194 padding
= seqno
& (1 << 29);
1195 mark
= seqno
& (1 << 23);
1196 ext
= seqno
& (1 << 28);
1197 cc
= (seqno
& 0xF000000) >> 24;
1199 timestamp
= ntohl(rtpheader
[1]);
1200 ssrc
= ntohl(rtpheader
[2]);
1202 if (!mark
&& rtp
->rxssrc
&& rtp
->rxssrc
!= ssrc
) {
1203 if (option_debug
|| rtpdebug
)
1204 ast_log(LOG_DEBUG
, "Forcing Marker bit, because SSRC has changed\n");
1211 /* Remove padding bytes */
1212 res
-= rtp
->rawdata
[AST_FRIENDLY_OFFSET
+ res
- 1];
1216 /* CSRC fields present */
1221 /* RTP Extension present */
1222 hdrlen
+= (ntohl(rtpheader
[hdrlen
/4]) & 0xffff) << 2;
1227 ast_log(LOG_WARNING
, "RTP Read too short (%d, expecting %d)\n", res
, hdrlen
);
1228 return &ast_null_frame
;
1231 rtp
->rxcount
++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */
1233 if (rtp
->rxcount
==1) {
1234 /* This is the first RTP packet successfully received from source */
1235 rtp
->seedrxseqno
= seqno
;
1238 /* Do not schedule RR if RTCP isn't run */
1239 if (rtp
->rtcp
&& rtp
->rtcp
->them
.sin_addr
.s_addr
&& rtp
->rtcp
->schedid
< 1) {
1240 /* Schedule transmission of Receiver Report */
1241 rtp
->rtcp
->schedid
= ast_sched_add(rtp
->sched
, ast_rtcp_calc_interval(rtp
), ast_rtcp_write
, rtp
);
1243 if ( (int)rtp
->lastrxseqno
- (int)seqno
> 100) /* if so it would indicate that the sender cycled; allow for misordering */
1244 rtp
->cycles
+= RTP_SEQ_MOD
;
1246 rtp
->lastrxseqno
= seqno
;
1248 if (rtp
->themssrc
==0)
1249 rtp
->themssrc
= ntohl(rtpheader
[2]); /* Record their SSRC to put in future RR */
1251 if (rtp_debug_test_addr(&sin
))
1252 ast_verbose("Got RTP packet from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
1253 ast_inet_ntoa(sin
.sin_addr
), ntohs(sin
.sin_port
), payloadtype
, seqno
, timestamp
,res
- hdrlen
);
1255 rtpPT
= ast_rtp_lookup_pt(rtp
, payloadtype
);
1256 if (!rtpPT
.isAstFormat
) {
1257 struct ast_frame
*f
= NULL
;
1259 /* This is special in-band data that's not one of our codecs */
1260 if (rtpPT
.code
== AST_RTP_DTMF
) {
1261 /* It's special -- rfc2833 process it */
1262 if (rtp_debug_test_addr(&sin
)) {
1263 unsigned char *data
;
1265 unsigned int event_end
;
1266 unsigned int duration
;
1267 data
= rtp
->rawdata
+ AST_FRIENDLY_OFFSET
+ hdrlen
;
1268 event
= ntohl(*((unsigned int *)(data
)));
1270 event_end
= ntohl(*((unsigned int *)(data
)));
1273 duration
= ntohl(*((unsigned int *)(data
)));
1275 ast_verbose("Got RTP RFC2833 from %s:%u (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
);
1277 f
= process_rfc2833(rtp
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
+ hdrlen
, res
- hdrlen
, seqno
, timestamp
);
1278 } else if (rtpPT
.code
== AST_RTP_CISCO_DTMF
) {
1279 /* It's really special -- process it the Cisco way */
1280 if (rtp
->lastevent
<= seqno
|| (rtp
->lastevent
>= 65530 && seqno
<= 6)) {
1281 f
= process_cisco_dtmf(rtp
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
+ hdrlen
, res
- hdrlen
);
1282 rtp
->lastevent
= seqno
;
1284 } else if (rtpPT
.code
== AST_RTP_CN
) {
1286 f
= process_rfc3389(rtp
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
+ hdrlen
, res
- hdrlen
);
1288 ast_log(LOG_NOTICE
, "Unknown RTP codec %d received from '%s'\n", payloadtype
, ast_inet_ntoa(rtp
->them
.sin_addr
));
1290 return f
? f
: &ast_null_frame
;
1292 rtp
->lastrxformat
= rtp
->f
.subclass
= rtpPT
.code
;
1293 rtp
->f
.frametype
= (rtp
->f
.subclass
< AST_FORMAT_MAX_AUDIO
) ? AST_FRAME_VOICE
: AST_FRAME_VIDEO
;
1296 rtp
->lastrxts
= timestamp
;
1298 rtp
->rxseqno
= seqno
;
1300 /* Record received timestamp as last received now */
1301 rtp
->lastrxts
= timestamp
;
1304 rtp
->f
.datalen
= res
- hdrlen
;
1305 rtp
->f
.data
= rtp
->rawdata
+ hdrlen
+ AST_FRIENDLY_OFFSET
;
1306 rtp
->f
.offset
= hdrlen
+ AST_FRIENDLY_OFFSET
;
1307 rtp
->f
.seqno
= seqno
;
1308 if (rtp
->f
.subclass
< AST_FORMAT_MAX_AUDIO
) {
1309 rtp
->f
.samples
= ast_codec_get_samples(&rtp
->f
);
1310 if (rtp
->f
.subclass
== AST_FORMAT_SLINEAR
)
1311 ast_frame_byteswap_be(&rtp
->f
);
1312 calc_rxstamp(&rtp
->f
.delivery
, rtp
, timestamp
, mark
);
1313 /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */
1314 ast_set_flag(&rtp
->f
, AST_FRFLAG_HAS_TIMING_INFO
);
1315 rtp
->f
.ts
= timestamp
/ 8;
1316 rtp
->f
.len
= rtp
->f
.samples
/ ( (ast_format_rate(rtp
->f
.subclass
) == 16000) ? 16 : 8 );
1318 /* Video -- samples is # of samples vs. 90000 */
1319 if (!rtp
->lastividtimestamp
)
1320 rtp
->lastividtimestamp
= timestamp
;
1321 rtp
->f
.samples
= timestamp
- rtp
->lastividtimestamp
;
1322 rtp
->lastividtimestamp
= timestamp
;
1323 rtp
->f
.delivery
.tv_sec
= 0;
1324 rtp
->f
.delivery
.tv_usec
= 0;
1326 rtp
->f
.subclass
|= 0x1;
1333 /* The following array defines the MIME Media type (and subtype) for each
1334 of our codecs, or RTP-specific data type. */
1336 struct rtpPayloadType payloadType
;
1340 {{1, AST_FORMAT_G723_1
}, "audio", "G723"},
1341 {{1, AST_FORMAT_GSM
}, "audio", "GSM"},
1342 {{1, AST_FORMAT_ULAW
}, "audio", "PCMU"},
1343 {{1, AST_FORMAT_ULAW
}, "audio", "G711U"},
1344 {{1, AST_FORMAT_ALAW
}, "audio", "PCMA"},
1345 {{1, AST_FORMAT_ALAW
}, "audio", "G711A"},
1346 {{1, AST_FORMAT_G726
}, "audio", "G726-32"},
1347 {{1, AST_FORMAT_ADPCM
}, "audio", "DVI4"},
1348 {{1, AST_FORMAT_SLINEAR
}, "audio", "L16"},
1349 {{1, AST_FORMAT_LPC10
}, "audio", "LPC"},
1350 {{1, AST_FORMAT_G729A
}, "audio", "G729"},
1351 {{1, AST_FORMAT_G729A
}, "audio", "G729A"},
1352 {{1, AST_FORMAT_SPEEX
}, "audio", "speex"},
1353 {{1, AST_FORMAT_ILBC
}, "audio", "iLBC"},
1354 {{1, AST_FORMAT_G722
}, "audio", "G722"},
1355 {{1, AST_FORMAT_G726_AAL2
}, "audio", "AAL2-G726-32"},
1356 {{0, AST_RTP_DTMF
}, "audio", "telephone-event"},
1357 {{0, AST_RTP_CISCO_DTMF
}, "audio", "cisco-telephone-event"},
1358 {{0, AST_RTP_CN
}, "audio", "CN"},
1359 {{1, AST_FORMAT_JPEG
}, "video", "JPEG"},
1360 {{1, AST_FORMAT_PNG
}, "video", "PNG"},
1361 {{1, AST_FORMAT_H261
}, "video", "H261"},
1362 {{1, AST_FORMAT_H263
}, "video", "H263"},
1363 {{1, AST_FORMAT_H263_PLUS
}, "video", "h263-1998"},
1364 {{1, AST_FORMAT_H264
}, "video", "H264"},
1367 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
1368 also, our own choices for dynamic payload types. This is our master
1369 table for transmission */
1370 static struct rtpPayloadType static_RTP_PT
[MAX_RTP_PT
] = {
1371 [0] = {1, AST_FORMAT_ULAW
},
1372 #ifdef USE_DEPRECATED_G726
1373 [2] = {1, AST_FORMAT_G726
}, /* Technically this is G.721, but if Cisco can do it, so can we... */
1375 [3] = {1, AST_FORMAT_GSM
},
1376 [4] = {1, AST_FORMAT_G723_1
},
1377 [5] = {1, AST_FORMAT_ADPCM
}, /* 8 kHz */
1378 [6] = {1, AST_FORMAT_ADPCM
}, /* 16 kHz */
1379 [7] = {1, AST_FORMAT_LPC10
},
1380 [8] = {1, AST_FORMAT_ALAW
},
1381 [9] = {1, AST_FORMAT_G722
},
1382 [10] = {1, AST_FORMAT_SLINEAR
}, /* 2 channels */
1383 [11] = {1, AST_FORMAT_SLINEAR
}, /* 1 channel */
1384 [13] = {0, AST_RTP_CN
},
1385 [16] = {1, AST_FORMAT_ADPCM
}, /* 11.025 kHz */
1386 [17] = {1, AST_FORMAT_ADPCM
}, /* 22.050 kHz */
1387 [18] = {1, AST_FORMAT_G729A
},
1388 [19] = {0, AST_RTP_CN
}, /* Also used for CN */
1389 [26] = {1, AST_FORMAT_JPEG
},
1390 [31] = {1, AST_FORMAT_H261
},
1391 [34] = {1, AST_FORMAT_H263
},
1392 [103] = {1, AST_FORMAT_H263_PLUS
},
1393 [97] = {1, AST_FORMAT_ILBC
},
1394 [99] = {1, AST_FORMAT_H264
},
1395 [101] = {0, AST_RTP_DTMF
},
1396 [110] = {1, AST_FORMAT_SPEEX
},
1397 [111] = {1, AST_FORMAT_G726
},
1398 [112] = {1, AST_FORMAT_G726_AAL2
},
1399 [121] = {0, AST_RTP_CISCO_DTMF
}, /* Must be type 121 */
1402 void ast_rtp_pt_clear(struct ast_rtp
* rtp
)
1409 ast_mutex_lock(&rtp
->bridge_lock
);
1411 for (i
= 0; i
< MAX_RTP_PT
; ++i
) {
1412 rtp
->current_RTP_PT
[i
].isAstFormat
= 0;
1413 rtp
->current_RTP_PT
[i
].code
= 0;
1416 rtp
->rtp_lookup_code_cache_isAstFormat
= 0;
1417 rtp
->rtp_lookup_code_cache_code
= 0;
1418 rtp
->rtp_lookup_code_cache_result
= 0;
1420 ast_mutex_unlock(&rtp
->bridge_lock
);
1423 void ast_rtp_pt_default(struct ast_rtp
* rtp
)
1427 ast_mutex_lock(&rtp
->bridge_lock
);
1429 /* Initialize to default payload types */
1430 for (i
= 0; i
< MAX_RTP_PT
; ++i
) {
1431 rtp
->current_RTP_PT
[i
].isAstFormat
= static_RTP_PT
[i
].isAstFormat
;
1432 rtp
->current_RTP_PT
[i
].code
= static_RTP_PT
[i
].code
;
1435 rtp
->rtp_lookup_code_cache_isAstFormat
= 0;
1436 rtp
->rtp_lookup_code_cache_code
= 0;
1437 rtp
->rtp_lookup_code_cache_result
= 0;
1439 ast_mutex_unlock(&rtp
->bridge_lock
);
1442 void ast_rtp_pt_copy(struct ast_rtp
*dest
, struct ast_rtp
*src
)
1446 ast_mutex_lock(&dest
->bridge_lock
);
1447 ast_mutex_lock(&src
->bridge_lock
);
1449 for (i
=0; i
< MAX_RTP_PT
; ++i
) {
1450 dest
->current_RTP_PT
[i
].isAstFormat
=
1451 src
->current_RTP_PT
[i
].isAstFormat
;
1452 dest
->current_RTP_PT
[i
].code
=
1453 src
->current_RTP_PT
[i
].code
;
1455 dest
->rtp_lookup_code_cache_isAstFormat
= 0;
1456 dest
->rtp_lookup_code_cache_code
= 0;
1457 dest
->rtp_lookup_code_cache_result
= 0;
1459 ast_mutex_unlock(&src
->bridge_lock
);
1460 ast_mutex_unlock(&dest
->bridge_lock
);
1463 /*! \brief Get channel driver interface structure */
1464 static struct ast_rtp_protocol
*get_proto(struct ast_channel
*chan
)
1466 struct ast_rtp_protocol
*cur
= NULL
;
1468 AST_LIST_LOCK(&protos
);
1469 AST_LIST_TRAVERSE(&protos
, cur
, list
) {
1470 if (cur
->type
== chan
->tech
->type
)
1473 AST_LIST_UNLOCK(&protos
);
1478 int ast_rtp_early_bridge(struct ast_channel
*dest
, struct ast_channel
*src
)
1480 struct ast_rtp
*destp
= NULL
, *srcp
= NULL
; /* Audio RTP Channels */
1481 struct ast_rtp
*vdestp
= NULL
, *vsrcp
= NULL
; /* Video RTP channels */
1482 struct ast_rtp_protocol
*destpr
= NULL
, *srcpr
= NULL
;
1483 enum ast_rtp_get_result audio_dest_res
= AST_RTP_GET_FAILED
, video_dest_res
= AST_RTP_GET_FAILED
;
1484 enum ast_rtp_get_result audio_src_res
= AST_RTP_GET_FAILED
, video_src_res
= AST_RTP_GET_FAILED
;
1485 int srccodec
, destcodec
, nat_active
= 0;
1488 ast_channel_lock(dest
);
1490 while(ast_channel_trylock(src
)) {
1491 ast_channel_unlock(dest
);
1493 ast_channel_lock(dest
);
1497 /* Find channel driver interfaces */
1498 destpr
= get_proto(dest
);
1500 srcpr
= get_proto(src
);
1503 ast_log(LOG_DEBUG
, "Channel '%s' has no RTP, not doing anything\n", dest
->name
);
1504 ast_channel_unlock(dest
);
1506 ast_channel_unlock(src
);
1511 ast_log(LOG_DEBUG
, "Channel '%s' has no RTP, not doing anything\n", src
? src
->name
: "<unspecified>");
1512 ast_channel_unlock(dest
);
1514 ast_channel_unlock(src
);
1518 /* Get audio and video interface (if native bridge is possible) */
1519 audio_dest_res
= destpr
->get_rtp_info(dest
, &destp
);
1520 video_dest_res
= destpr
->get_vrtp_info
? destpr
->get_vrtp_info(dest
, &vdestp
) : AST_RTP_GET_FAILED
;
1522 audio_src_res
= srcpr
->get_rtp_info(src
, &srcp
);
1523 video_src_res
= srcpr
->get_vrtp_info
? srcpr
->get_vrtp_info(src
, &vsrcp
) : AST_RTP_GET_FAILED
;
1526 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1527 if (audio_dest_res
!= AST_RTP_TRY_NATIVE
) {
1528 /* Somebody doesn't want to play... */
1529 ast_channel_unlock(dest
);
1531 ast_channel_unlock(src
);
1534 if (audio_src_res
== AST_RTP_TRY_NATIVE
&& srcpr
->get_codec
)
1535 srccodec
= srcpr
->get_codec(src
);
1538 if (audio_dest_res
== AST_RTP_TRY_NATIVE
&& destpr
->get_codec
)
1539 destcodec
= destpr
->get_codec(dest
);
1542 /* Ensure we have at least one matching codec */
1543 if (!(srccodec
& destcodec
)) {
1544 ast_channel_unlock(dest
);
1546 ast_channel_unlock(src
);
1549 /* Consider empty media as non-existant */
1550 if (audio_src_res
== AST_RTP_TRY_NATIVE
&& !srcp
->them
.sin_addr
.s_addr
)
1552 /* If the client has NAT stuff turned on then just safe NAT is active */
1553 if (srcp
&& (srcp
->nat
|| ast_test_flag(srcp
, FLAG_NAT_ACTIVE
)))
1555 /* Bridge media early */
1556 if (destpr
->set_rtp_peer(dest
, srcp
, vsrcp
, srccodec
, nat_active
))
1557 ast_log(LOG_WARNING
, "Channel '%s' failed to setup early bridge to '%s'\n", dest
->name
, src
? src
->name
: "<unspecified>");
1558 ast_channel_unlock(dest
);
1560 ast_channel_unlock(src
);
1562 ast_log(LOG_DEBUG
, "Setting early bridge SDP of '%s' with that of '%s'\n", dest
->name
, src
? src
->name
: "<unspecified>");
1566 int ast_rtp_make_compatible(struct ast_channel
*dest
, struct ast_channel
*src
, int media
)
1568 struct ast_rtp
*destp
= NULL
, *srcp
= NULL
; /* Audio RTP Channels */
1569 struct ast_rtp
*vdestp
= NULL
, *vsrcp
= NULL
; /* Video RTP channels */
1570 struct ast_rtp_protocol
*destpr
= NULL
, *srcpr
= NULL
;
1571 enum ast_rtp_get_result audio_dest_res
= AST_RTP_GET_FAILED
, video_dest_res
= AST_RTP_GET_FAILED
;
1572 enum ast_rtp_get_result audio_src_res
= AST_RTP_GET_FAILED
, video_src_res
= AST_RTP_GET_FAILED
;
1573 int srccodec
, destcodec
;
1576 ast_channel_lock(dest
);
1577 while(ast_channel_trylock(src
)) {
1578 ast_channel_unlock(dest
);
1580 ast_channel_lock(dest
);
1583 /* Find channel driver interfaces */
1584 if (!(destpr
= get_proto(dest
))) {
1586 ast_log(LOG_DEBUG
, "Channel '%s' has no RTP, not doing anything\n", dest
->name
);
1587 ast_channel_unlock(dest
);
1588 ast_channel_unlock(src
);
1591 if (!(srcpr
= get_proto(src
))) {
1593 ast_log(LOG_DEBUG
, "Channel '%s' has no RTP, not doing anything\n", src
->name
);
1594 ast_channel_unlock(dest
);
1595 ast_channel_unlock(src
);
1599 /* Get audio and video interface (if native bridge is possible) */
1600 audio_dest_res
= destpr
->get_rtp_info(dest
, &destp
);
1601 video_dest_res
= destpr
->get_vrtp_info
? destpr
->get_vrtp_info(dest
, &vdestp
) : AST_RTP_GET_FAILED
;
1602 audio_src_res
= srcpr
->get_rtp_info(src
, &srcp
);
1603 video_src_res
= srcpr
->get_vrtp_info
? srcpr
->get_vrtp_info(src
, &vsrcp
) : AST_RTP_GET_FAILED
;
1605 /* Ensure we have at least one matching codec */
1606 if (srcpr
->get_codec
)
1607 srccodec
= srcpr
->get_codec(src
);
1610 if (destpr
->get_codec
)
1611 destcodec
= destpr
->get_codec(dest
);
1615 /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */
1616 if (audio_dest_res
!= AST_RTP_TRY_NATIVE
|| audio_src_res
!= AST_RTP_TRY_NATIVE
|| !(srccodec
& destcodec
)) {
1617 /* Somebody doesn't want to play... */
1618 ast_channel_unlock(dest
);
1619 ast_channel_unlock(src
);
1622 ast_rtp_pt_copy(destp
, srcp
);
1623 if (vdestp
&& vsrcp
)
1624 ast_rtp_pt_copy(vdestp
, vsrcp
);
1627 if (destpr
->set_rtp_peer(dest
, srcp
, vsrcp
, srccodec
, ast_test_flag(srcp
, FLAG_NAT_ACTIVE
)))
1628 ast_log(LOG_WARNING
, "Channel '%s' failed to setup early bridge to '%s'\n", dest
->name
, src
->name
);
1630 ast_channel_unlock(dest
);
1631 ast_channel_unlock(src
);
1633 ast_log(LOG_DEBUG
, "Seeded SDP of '%s' with that of '%s'\n", dest
->name
, src
->name
);
1637 /*! \brief Make a note of a RTP payload type that was seen in a SDP "m=" line.
1638 * By default, use the well-known value for this type (although it may
1639 * still be set to a different value by a subsequent "a=rtpmap:" line)
1641 void ast_rtp_set_m_type(struct ast_rtp
* rtp
, int pt
)
1643 if (pt
< 0 || pt
> MAX_RTP_PT
|| static_RTP_PT
[pt
].code
== 0)
1644 return; /* bogus payload type */
1646 ast_mutex_lock(&rtp
->bridge_lock
);
1647 rtp
->current_RTP_PT
[pt
] = static_RTP_PT
[pt
];
1648 ast_mutex_unlock(&rtp
->bridge_lock
);
1651 /*! \brief remove setting from payload type list if the rtpmap header indicates
1652 an unknown media type */
1653 void ast_rtp_unset_m_type(struct ast_rtp
* rtp
, int pt
)
1655 if (pt
< 0 || pt
> MAX_RTP_PT
)
1656 return; /* bogus payload type */
1658 ast_mutex_lock(&rtp
->bridge_lock
);
1659 rtp
->current_RTP_PT
[pt
].isAstFormat
= 0;
1660 rtp
->current_RTP_PT
[pt
].code
= 0;
1661 ast_mutex_unlock(&rtp
->bridge_lock
);
1664 /*! \brief Make a note of a RTP payload type (with MIME type) that was seen in
1665 * an SDP "a=rtpmap:" line.
1666 * \return 0 if the MIME type was found and set, -1 if it wasn't found
1668 int ast_rtp_set_rtpmap_type(struct ast_rtp
*rtp
, int pt
,
1669 char *mimeType
, char *mimeSubtype
,
1670 enum ast_rtp_options options
)
1675 if (pt
< 0 || pt
> MAX_RTP_PT
)
1676 return -1; /* bogus payload type */
1678 ast_mutex_lock(&rtp
->bridge_lock
);
1680 for (i
= 0; i
< sizeof(mimeTypes
)/sizeof(mimeTypes
[0]); ++i
) {
1681 if (strcasecmp(mimeSubtype
, mimeTypes
[i
].subtype
) == 0 &&
1682 strcasecmp(mimeType
, mimeTypes
[i
].type
) == 0) {
1684 rtp
->current_RTP_PT
[pt
] = mimeTypes
[i
].payloadType
;
1685 if ((mimeTypes
[i
].payloadType
.code
== AST_FORMAT_G726
) &&
1686 mimeTypes
[i
].payloadType
.isAstFormat
&&
1687 (options
& AST_RTP_OPT_G726_NONSTANDARD
))
1688 rtp
->current_RTP_PT
[pt
].code
= AST_FORMAT_G726_AAL2
;
1693 ast_mutex_unlock(&rtp
->bridge_lock
);
1695 return (found
? 0 : -1);
1698 /*! \brief Return the union of all of the codecs that were set by rtp_set...() calls
1699 * They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
1700 void ast_rtp_get_current_formats(struct ast_rtp
* rtp
,
1701 int* astFormats
, int* nonAstFormats
)
1705 ast_mutex_lock(&rtp
->bridge_lock
);
1707 *astFormats
= *nonAstFormats
= 0;
1708 for (pt
= 0; pt
< MAX_RTP_PT
; ++pt
) {
1709 if (rtp
->current_RTP_PT
[pt
].isAstFormat
) {
1710 *astFormats
|= rtp
->current_RTP_PT
[pt
].code
;
1712 *nonAstFormats
|= rtp
->current_RTP_PT
[pt
].code
;
1716 ast_mutex_unlock(&rtp
->bridge_lock
);
1721 struct rtpPayloadType
ast_rtp_lookup_pt(struct ast_rtp
* rtp
, int pt
)
1723 struct rtpPayloadType result
;
1725 result
.isAstFormat
= result
.code
= 0;
1727 if (pt
< 0 || pt
> MAX_RTP_PT
)
1728 return result
; /* bogus payload type */
1730 /* Start with negotiated codecs */
1731 ast_mutex_lock(&rtp
->bridge_lock
);
1732 result
= rtp
->current_RTP_PT
[pt
];
1733 ast_mutex_unlock(&rtp
->bridge_lock
);
1735 /* If it doesn't exist, check our static RTP type list, just in case */
1737 result
= static_RTP_PT
[pt
];
1742 /*! \brief Looks up an RTP code out of our *static* outbound list */
1743 int ast_rtp_lookup_code(struct ast_rtp
* rtp
, const int isAstFormat
, const int code
)
1747 ast_mutex_lock(&rtp
->bridge_lock
);
1749 if (isAstFormat
== rtp
->rtp_lookup_code_cache_isAstFormat
&&
1750 code
== rtp
->rtp_lookup_code_cache_code
) {
1751 /* Use our cached mapping, to avoid the overhead of the loop below */
1752 pt
= rtp
->rtp_lookup_code_cache_result
;
1753 ast_mutex_unlock(&rtp
->bridge_lock
);
1757 /* Check the dynamic list first */
1758 for (pt
= 0; pt
< MAX_RTP_PT
; ++pt
) {
1759 if (rtp
->current_RTP_PT
[pt
].code
== code
&& rtp
->current_RTP_PT
[pt
].isAstFormat
== isAstFormat
) {
1760 rtp
->rtp_lookup_code_cache_isAstFormat
= isAstFormat
;
1761 rtp
->rtp_lookup_code_cache_code
= code
;
1762 rtp
->rtp_lookup_code_cache_result
= pt
;
1763 ast_mutex_unlock(&rtp
->bridge_lock
);
1768 /* Then the static list */
1769 for (pt
= 0; pt
< MAX_RTP_PT
; ++pt
) {
1770 if (static_RTP_PT
[pt
].code
== code
&& static_RTP_PT
[pt
].isAstFormat
== isAstFormat
) {
1771 rtp
->rtp_lookup_code_cache_isAstFormat
= isAstFormat
;
1772 rtp
->rtp_lookup_code_cache_code
= code
;
1773 rtp
->rtp_lookup_code_cache_result
= pt
;
1774 ast_mutex_unlock(&rtp
->bridge_lock
);
1779 ast_mutex_unlock(&rtp
->bridge_lock
);
1784 const char *ast_rtp_lookup_mime_subtype(const int isAstFormat
, const int code
,
1785 enum ast_rtp_options options
)
1789 for (i
= 0; i
< sizeof(mimeTypes
)/sizeof(mimeTypes
[0]); ++i
) {
1790 if ((mimeTypes
[i
].payloadType
.code
== code
) && (mimeTypes
[i
].payloadType
.isAstFormat
== isAstFormat
)) {
1792 (code
== AST_FORMAT_G726_AAL2
) &&
1793 (options
& AST_RTP_OPT_G726_NONSTANDARD
))
1796 return mimeTypes
[i
].subtype
;
1803 char *ast_rtp_lookup_mime_multiple(char *buf
, size_t size
, const int capability
,
1804 const int isAstFormat
, enum ast_rtp_options options
)
1814 snprintf(end
, size
, "0x%x (", capability
);
1821 for (format
= 1; format
< AST_RTP_MAX
; format
<<= 1) {
1822 if (capability
& format
) {
1823 const char *name
= ast_rtp_lookup_mime_subtype(isAstFormat
, format
, options
);
1825 snprintf(end
, size
, "%s|", name
);
1833 snprintf(start
, size
, "nothing)");
1840 static int rtp_socket(void)
1844 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1846 flags
= fcntl(s
, F_GETFL
);
1847 fcntl(s
, F_SETFL
, flags
| O_NONBLOCK
);
1850 setsockopt(s
, SOL_SOCKET
, SO_NO_CHECK
, &nochecksums
, sizeof(nochecksums
));
1857 * \brief Initialize a new RTCP session.
1859 * \returns The newly initialized RTCP session.
1861 static struct ast_rtcp
*ast_rtcp_new(void)
1863 struct ast_rtcp
*rtcp
;
1865 if (!(rtcp
= ast_calloc(1, sizeof(*rtcp
))))
1867 rtcp
->s
= rtp_socket();
1868 rtcp
->us
.sin_family
= AF_INET
;
1869 rtcp
->them
.sin_family
= AF_INET
;
1874 ast_log(LOG_WARNING
, "Unable to allocate RTCP socket: %s\n", strerror(errno
));
1882 * \brief Initialize a new RTP structure.
1885 void ast_rtp_new_init(struct ast_rtp
*rtp
)
1887 ast_mutex_init(&rtp
->bridge_lock
);
1889 rtp
->them
.sin_family
= AF_INET
;
1890 rtp
->us
.sin_family
= AF_INET
;
1891 rtp
->ssrc
= ast_random();
1892 rtp
->seqno
= ast_random() & 0xffff;
1893 ast_set_flag(rtp
, FLAG_HAS_DTMF
);
1898 struct ast_rtp
*ast_rtp_new_with_bindaddr(struct sched_context
*sched
, struct io_context
*io
, int rtcpenable
, int callbackmode
, struct in_addr addr
)
1900 struct ast_rtp
*rtp
;
1905 if (!(rtp
= ast_calloc(1, sizeof(*rtp
))))
1908 ast_rtp_new_init(rtp
);
1910 rtp
->s
= rtp_socket();
1913 ast_log(LOG_ERROR
, "Unable to allocate socket: %s\n", strerror(errno
));
1916 if (sched
&& rtcpenable
) {
1918 rtp
->rtcp
= ast_rtcp_new();
1921 /* Select a random port number in the range of possible RTP */
1922 x
= (ast_random() % (rtpend
-rtpstart
)) + rtpstart
;
1924 /* Save it for future references. */
1926 /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */
1928 /* Must be an even port number by RTP spec */
1929 rtp
->us
.sin_port
= htons(x
);
1930 rtp
->us
.sin_addr
= addr
;
1931 /* If there's rtcp, initialize it as well. */
1933 rtp
->rtcp
->us
.sin_port
= htons(x
+ 1);
1934 rtp
->rtcp
->us
.sin_addr
= addr
;
1936 /* Try to bind it/them. */
1937 if (!(first
= bind(rtp
->s
, (struct sockaddr
*)&rtp
->us
, sizeof(rtp
->us
))) &&
1938 (!rtp
->rtcp
|| !bind(rtp
->rtcp
->s
, (struct sockaddr
*)&rtp
->rtcp
->us
, sizeof(rtp
->rtcp
->us
))))
1941 /* Primary bind succeeded! Gotta recreate it */
1943 rtp
->s
= rtp_socket();
1945 if (errno
!= EADDRINUSE
) {
1946 /* We got an error that wasn't expected, abort! */
1947 ast_log(LOG_ERROR
, "Unexpected bind error: %s\n", strerror(errno
));
1950 close(rtp
->rtcp
->s
);
1956 /* The port was used, increment it (by two). */
1958 /* Did we go over the limit ? */
1960 /* then, start from the begingig. */
1961 x
= (rtpstart
+ 1) & ~1;
1962 /* Check if we reached the place were we started. */
1963 if (x
== startplace
) {
1964 /* If so, there's no ports available. */
1965 ast_log(LOG_ERROR
, "No RTP ports remaining. Can't setup media stream for this call.\n");
1968 close(rtp
->rtcp
->s
);
1978 rtp
->ioid
= ast_io_add(rtp
->io
, rtp
->s
, rtpread
, AST_IO_IN
, rtp
);
1979 ast_set_flag(rtp
, FLAG_CALLBACK_MODE
);
1981 ast_rtp_pt_default(rtp
);
1985 struct ast_rtp
*ast_rtp_new(struct sched_context
*sched
, struct io_context
*io
, int rtcpenable
, int callbackmode
)
1989 memset(&ia
, 0, sizeof(ia
));
1990 return ast_rtp_new_with_bindaddr(sched
, io
, rtcpenable
, callbackmode
, ia
);
1993 int ast_rtp_settos(struct ast_rtp
*rtp
, int tos
)
1997 if ((res
= setsockopt(rtp
->s
, IPPROTO_IP
, IP_TOS
, &tos
, sizeof(tos
))))
1998 ast_log(LOG_WARNING
, "Unable to set TOS to %d\n", tos
);
2002 void ast_rtp_new_source(struct ast_rtp
*rtp
)
2004 rtp
->set_marker_bit
= 1;
2005 rtp
->ssrc
= ast_random();
2009 void ast_rtp_set_peer(struct ast_rtp
*rtp
, struct sockaddr_in
*them
)
2011 rtp
->them
.sin_port
= them
->sin_port
;
2012 rtp
->them
.sin_addr
= them
->sin_addr
;
2014 rtp
->rtcp
->them
.sin_port
= htons(ntohs(them
->sin_port
) + 1);
2015 rtp
->rtcp
->them
.sin_addr
= them
->sin_addr
;
2020 int ast_rtp_get_peer(struct ast_rtp
*rtp
, struct sockaddr_in
*them
)
2022 if ((them
->sin_family
!= AF_INET
) ||
2023 (them
->sin_port
!= rtp
->them
.sin_port
) ||
2024 (them
->sin_addr
.s_addr
!= rtp
->them
.sin_addr
.s_addr
)) {
2025 them
->sin_family
= AF_INET
;
2026 them
->sin_port
= rtp
->them
.sin_port
;
2027 them
->sin_addr
= rtp
->them
.sin_addr
;
2033 void ast_rtp_get_us(struct ast_rtp
*rtp
, struct sockaddr_in
*us
)
2038 struct ast_rtp
*ast_rtp_get_bridged(struct ast_rtp
*rtp
)
2040 struct ast_rtp
*bridged
= NULL
;
2042 ast_mutex_lock(&rtp
->bridge_lock
);
2043 bridged
= rtp
->bridged
;
2044 ast_mutex_unlock(&rtp
->bridge_lock
);
2049 void ast_rtp_stop(struct ast_rtp
*rtp
)
2051 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2053 memset(&rtp
->them
.sin_addr
, 0, sizeof(rtp
->them
.sin_addr
));
2054 memset(&rtp
->them
.sin_port
, 0, sizeof(rtp
->them
.sin_port
));
2056 memset(&rtp
->rtcp
->them
.sin_addr
, 0, sizeof(rtp
->rtcp
->them
.sin_addr
));
2057 memset(&rtp
->rtcp
->them
.sin_port
, 0, sizeof(rtp
->rtcp
->them
.sin_port
));
2060 ast_clear_flag(rtp
, FLAG_P2P_SENT_MARK
);
2063 void ast_rtp_reset(struct ast_rtp
*rtp
)
2065 memset(&rtp
->rxcore
, 0, sizeof(rtp
->rxcore
));
2066 memset(&rtp
->txcore
, 0, sizeof(rtp
->txcore
));
2067 memset(&rtp
->dtmfmute
, 0, sizeof(rtp
->dtmfmute
));
2069 rtp
->lastdigitts
= 0;
2071 rtp
->lastividtimestamp
= 0;
2072 rtp
->lastovidtimestamp
= 0;
2073 rtp
->lasteventseqn
= 0;
2075 rtp
->lasttxformat
= 0;
2076 rtp
->lastrxformat
= 0;
2078 rtp
->dtmfsamples
= 0;
2083 char *ast_rtp_get_quality(struct ast_rtp
*rtp
, struct ast_rtp_quality
*qual
)
2087 *themssrc their ssrc
2089 *rxjitter our calculated jitter(rx)
2090 *rxcount no. received packets
2091 *txjitter reported jitter of the other end
2092 *txcount transmitted packets
2093 *rlp remote lost packets
2094 *rtt round trip time
2098 qual
->local_ssrc
= rtp
->ssrc
;
2099 qual
->local_jitter
= rtp
->rxjitter
;
2100 qual
->local_count
= rtp
->rxcount
;
2101 qual
->remote_ssrc
= rtp
->themssrc
;
2102 qual
->remote_count
= rtp
->txcount
;
2104 qual
->local_lostpackets
= rtp
->rtcp
->expected_prior
- rtp
->rtcp
->received_prior
;
2105 qual
->remote_lostpackets
= rtp
->rtcp
->reported_lost
;
2106 qual
->remote_jitter
= rtp
->rtcp
->reported_jitter
/ 65536.0;
2107 qual
->rtt
= rtp
->rtcp
->rtt
;
2111 snprintf(rtp
->rtcp
->quality
, sizeof(rtp
->rtcp
->quality
),
2112 "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f",
2115 rtp
->rtcp
->expected_prior
- rtp
->rtcp
->received_prior
,
2118 (double)rtp
->rtcp
->reported_jitter
/ 65536.0,
2120 rtp
->rtcp
->reported_lost
,
2122 return rtp
->rtcp
->quality
;
2124 return "<Unknown> - RTP/RTCP has already been destroyed";
2127 void ast_rtp_destroy(struct ast_rtp
*rtp
)
2129 if (rtcp_debug_test_addr(&rtp
->them
) || rtcpstats
) {
2130 /*Print some info on the call here */
2131 ast_verbose(" RTP-stats\n");
2132 ast_verbose("* Our Receiver:\n");
2133 ast_verbose(" SSRC: %u\n", rtp
->themssrc
);
2134 ast_verbose(" Received packets: %u\n", rtp
->rxcount
);
2135 ast_verbose(" Lost packets: %u\n", rtp
->rtcp
->expected_prior
- rtp
->rtcp
->received_prior
);
2136 ast_verbose(" Jitter: %.4f\n", rtp
->rxjitter
);
2137 ast_verbose(" Transit: %.4f\n", rtp
->rxtransit
);
2138 ast_verbose(" RR-count: %u\n", rtp
->rtcp
->rr_count
);
2139 ast_verbose("* Our Sender:\n");
2140 ast_verbose(" SSRC: %u\n", rtp
->ssrc
);
2141 ast_verbose(" Sent packets: %u\n", rtp
->txcount
);
2142 ast_verbose(" Lost packets: %u\n", rtp
->rtcp
->reported_lost
);
2143 ast_verbose(" Jitter: %u\n", rtp
->rtcp
->reported_jitter
/ (unsigned int)65536.0);
2144 ast_verbose(" SR-count: %u\n", rtp
->rtcp
->sr_count
);
2145 ast_verbose(" RTT: %f\n", rtp
->rtcp
->rtt
);
2149 ast_smoother_free(rtp
->smoother
);
2151 ast_io_remove(rtp
->io
, rtp
->ioid
);
2155 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2156 close(rtp
->rtcp
->s
);
2161 ast_mutex_destroy(&rtp
->bridge_lock
);
2166 static unsigned int calc_txstamp(struct ast_rtp
*rtp
, struct timeval
*delivery
)
2170 if (ast_tvzero(rtp
->txcore
)) {
2171 rtp
->txcore
= ast_tvnow();
2172 /* Round to 20ms for nice, pretty timestamps */
2173 rtp
->txcore
.tv_usec
-= rtp
->txcore
.tv_usec
% 20000;
2175 /* Use previous txcore if available */
2176 t
= (delivery
&& !ast_tvzero(*delivery
)) ? *delivery
: ast_tvnow();
2177 ms
= ast_tvdiff_ms(t
, rtp
->txcore
);
2180 /* Use what we just got for next time */
2182 return (unsigned int) ms
;
2185 /*! \brief Send begin frames for DTMF */
2186 int ast_rtp_senddigit_begin(struct ast_rtp
*rtp
, char digit
)
2188 unsigned int *rtpheader
;
2189 int hdrlen
= 12, res
= 0, i
= 0, payload
= 0;
2192 if ((digit
<= '9') && (digit
>= '0'))
2194 else if (digit
== '*')
2196 else if (digit
== '#')
2198 else if ((digit
>= 'A') && (digit
<= 'D'))
2199 digit
= digit
- 'A' + 12;
2200 else if ((digit
>= 'a') && (digit
<= 'd'))
2201 digit
= digit
- 'a' + 12;
2203 ast_log(LOG_WARNING
, "Don't know how to represent '%c'\n", digit
);
2207 /* If we have no peer, return immediately */
2208 if (!rtp
->them
.sin_addr
.s_addr
|| !rtp
->them
.sin_port
)
2211 payload
= ast_rtp_lookup_code(rtp
, 0, AST_RTP_DTMF
);
2213 rtp
->dtmfmute
= ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2214 rtp
->send_duration
= 160;
2216 /* Get a pointer to the header */
2217 rtpheader
= (unsigned int *)data
;
2218 rtpheader
[0] = htonl((2 << 30) | (1 << 23) | (payload
<< 16) | (rtp
->seqno
));
2219 rtpheader
[1] = htonl(rtp
->lastdigitts
);
2220 rtpheader
[2] = htonl(rtp
->ssrc
);
2222 for (i
= 0; i
< 2; i
++) {
2223 rtpheader
[3] = htonl((digit
<< 24) | (0xa << 16) | (rtp
->send_duration
));
2224 res
= sendto(rtp
->s
, (void *) rtpheader
, hdrlen
+ 4, 0, (struct sockaddr
*) &rtp
->them
, sizeof(rtp
->them
));
2226 ast_log(LOG_ERROR
, "RTP Transmission error to %s:%u: %s\n",
2227 ast_inet_ntoa(rtp
->them
.sin_addr
),
2228 ntohs(rtp
->them
.sin_port
), strerror(errno
));
2229 if (rtp_debug_test_addr(&rtp
->them
))
2230 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2231 ast_inet_ntoa(rtp
->them
.sin_addr
),
2232 ntohs(rtp
->them
.sin_port
), payload
, rtp
->seqno
, rtp
->lastdigitts
, res
- hdrlen
);
2233 /* Increment sequence number */
2235 /* Increment duration */
2236 rtp
->send_duration
+= 160;
2237 /* Clear marker bit and set seqno */
2238 rtpheader
[0] = htonl((2 << 30) | (payload
<< 16) | (rtp
->seqno
));
2241 /* Since we received a begin, we can safely store the digit and disable any compensation */
2242 rtp
->sending_digit
= 1;
2243 rtp
->send_digit
= digit
;
2244 rtp
->send_payload
= payload
;
2249 /*! \brief Send continuation frame for DTMF */
2250 static int ast_rtp_senddigit_continuation(struct ast_rtp
*rtp
)
2252 unsigned int *rtpheader
;
2253 int hdrlen
= 12, res
= 0;
2256 if (!rtp
->them
.sin_addr
.s_addr
|| !rtp
->them
.sin_port
)
2259 /* Setup packet to send */
2260 rtpheader
= (unsigned int *)data
;
2261 rtpheader
[0] = htonl((2 << 30) | (1 << 23) | (rtp
->send_payload
<< 16) | (rtp
->seqno
));
2262 rtpheader
[1] = htonl(rtp
->lastdigitts
);
2263 rtpheader
[2] = htonl(rtp
->ssrc
);
2264 rtpheader
[3] = htonl((rtp
->send_digit
<< 24) | (0xa << 16) | (rtp
->send_duration
));
2265 rtpheader
[0] = htonl((2 << 30) | (rtp
->send_payload
<< 16) | (rtp
->seqno
));
2268 res
= sendto(rtp
->s
, (void *) rtpheader
, hdrlen
+ 4, 0, (struct sockaddr
*) &rtp
->them
, sizeof(rtp
->them
));
2270 ast_log(LOG_ERROR
, "RTP Transmission error to %s:%d: %s\n",
2271 ast_inet_ntoa(rtp
->them
.sin_addr
),
2272 ntohs(rtp
->them
.sin_port
), strerror(errno
));
2273 if (rtp_debug_test_addr(&rtp
->them
))
2274 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2275 ast_inet_ntoa(rtp
->them
.sin_addr
),
2276 ntohs(rtp
->them
.sin_port
), rtp
->send_payload
, rtp
->seqno
, rtp
->lastdigitts
, res
- hdrlen
);
2278 /* Increment sequence number */
2280 /* Increment duration */
2281 rtp
->send_duration
+= 160;
2286 /*! \brief Send end packets for DTMF */
2287 int ast_rtp_senddigit_end(struct ast_rtp
*rtp
, char digit
)
2289 unsigned int *rtpheader
;
2290 int hdrlen
= 12, res
= 0, i
= 0;
2293 /* If no address, then bail out */
2294 if (!rtp
->them
.sin_addr
.s_addr
|| !rtp
->them
.sin_port
)
2297 if ((digit
<= '9') && (digit
>= '0'))
2299 else if (digit
== '*')
2301 else if (digit
== '#')
2303 else if ((digit
>= 'A') && (digit
<= 'D'))
2304 digit
= digit
- 'A' + 12;
2305 else if ((digit
>= 'a') && (digit
<= 'd'))
2306 digit
= digit
- 'a' + 12;
2308 ast_log(LOG_WARNING
, "Don't know how to represent '%c'\n", digit
);
2312 rtp
->dtmfmute
= ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2314 rtpheader
= (unsigned int *)data
;
2315 rtpheader
[0] = htonl((2 << 30) | (1 << 23) | (rtp
->send_payload
<< 16) | (rtp
->seqno
));
2316 rtpheader
[1] = htonl(rtp
->lastdigitts
);
2317 rtpheader
[2] = htonl(rtp
->ssrc
);
2318 rtpheader
[3] = htonl((digit
<< 24) | (0xa << 16) | (rtp
->send_duration
));
2320 rtpheader
[3] |= htonl((1 << 23));
2321 rtpheader
[0] = htonl((2 << 30) | (rtp
->send_payload
<< 16) | (rtp
->seqno
));
2322 /* Send 3 termination packets */
2323 for (i
= 0; i
< 3; i
++) {
2324 res
= sendto(rtp
->s
, (void *) rtpheader
, hdrlen
+ 4, 0, (struct sockaddr
*) &rtp
->them
, sizeof(rtp
->them
));
2326 ast_log(LOG_ERROR
, "RTP Transmission error to %s:%d: %s\n",
2327 ast_inet_ntoa(rtp
->them
.sin_addr
),
2328 ntohs(rtp
->them
.sin_port
), strerror(errno
));
2329 if (rtp_debug_test_addr(&rtp
->them
))
2330 ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2331 ast_inet_ntoa(rtp
->them
.sin_addr
),
2332 ntohs(rtp
->them
.sin_port
), rtp
->send_payload
, rtp
->seqno
, rtp
->lastdigitts
, res
- hdrlen
);
2334 rtp
->sending_digit
= 0;
2335 rtp
->send_digit
= 0;
2336 /* Increment lastdigitts */
2337 rtp
->lastdigitts
+= 960;
2343 /*! \brief Public function: Send an H.261 fast update request, some devices need this rather than SIP XML */
2344 int ast_rtcp_send_h261fur(void *data
)
2346 struct ast_rtp
*rtp
= data
;
2349 rtp
->rtcp
->sendfur
= 1;
2350 res
= ast_rtcp_write(data
);
2355 /*! \brief Send RTCP sender's report */
2356 static int ast_rtcp_write_sr(const void *data
)
2358 struct ast_rtp
*rtp
= (struct ast_rtp
*)data
;
2362 unsigned int now_lsw
;
2363 unsigned int now_msw
;
2364 unsigned int *rtcpheader
;
2366 unsigned int extended
;
2367 unsigned int expected
;
2368 unsigned int expected_interval
;
2369 unsigned int received_interval
;
2372 struct timeval dlsr
;
2375 /* Commented condition is always not NULL if rtp->rtcp is not NULL */
2376 if (!rtp
|| !rtp
->rtcp
/* || (&rtp->rtcp->them.sin_addr == 0)*/)
2379 if (!rtp
->rtcp
->them
.sin_addr
.s_addr
) { /* This'll stop rtcp for this rtp session */
2380 ast_verbose("RTCP SR transmission error, rtcp halted\n");
2381 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2385 gettimeofday(&now
, NULL
);
2386 timeval2ntp(now
, &now_msw
, &now_lsw
); /* fill thses ones in from utils.c*/
2387 rtcpheader
= (unsigned int *)bdata
;
2388 rtcpheader
[1] = htonl(rtp
->ssrc
); /* Our SSRC */
2389 rtcpheader
[2] = htonl(now_msw
); /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/
2390 rtcpheader
[3] = htonl(now_lsw
); /* now, LSW */
2391 rtcpheader
[4] = htonl(rtp
->lastts
); /* FIXME shouldn't be that, it should be now */
2392 rtcpheader
[5] = htonl(rtp
->txcount
); /* No. packets sent */
2393 rtcpheader
[6] = htonl(rtp
->txoctetcount
); /* No. bytes sent */
2396 extended
= rtp
->cycles
+ rtp
->lastrxseqno
;
2397 expected
= extended
- rtp
->seedrxseqno
+ 1;
2398 if (rtp
->rxcount
> expected
)
2399 expected
+= rtp
->rxcount
- expected
;
2400 lost
= expected
- rtp
->rxcount
;
2401 expected_interval
= expected
- rtp
->rtcp
->expected_prior
;
2402 rtp
->rtcp
->expected_prior
= expected
;
2403 received_interval
= rtp
->rxcount
- rtp
->rtcp
->received_prior
;
2404 rtp
->rtcp
->received_prior
= rtp
->rxcount
;
2405 lost_interval
= expected_interval
- received_interval
;
2406 if (expected_interval
== 0 || lost_interval
<= 0)
2409 fraction
= (lost_interval
<< 8) / expected_interval
;
2410 timersub(&now
, &rtp
->rtcp
->rxlsr
, &dlsr
);
2411 rtcpheader
[7] = htonl(rtp
->themssrc
);
2412 rtcpheader
[8] = htonl(((fraction
& 0xff) << 24) | (lost
& 0xffffff));
2413 rtcpheader
[9] = htonl((rtp
->cycles
) | ((rtp
->lastrxseqno
& 0xffff)));
2414 rtcpheader
[10] = htonl((unsigned int)(rtp
->rxjitter
* 65536.));
2415 rtcpheader
[11] = htonl(rtp
->rtcp
->themrxlsr
);
2416 rtcpheader
[12] = htonl((((dlsr
.tv_sec
* 1000) + (dlsr
.tv_usec
/ 1000)) * 65536) / 1000);
2419 rtcpheader
[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR
<< 16) | ((len
/4)-1));
2421 if (rtp
->rtcp
->sendfur
) {
2422 rtcpheader
[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR
<< 16) | 1);
2423 rtcpheader
[14] = htonl(rtp
->ssrc
); /* Our SSRC */
2425 rtp
->rtcp
->sendfur
= 0;
2428 /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */
2429 /* it can change mid call, and SDES can't) */
2430 rtcpheader
[len
/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES
<< 16) | 2);
2431 rtcpheader
[(len
/4)+1] = htonl(rtp
->ssrc
); /* Our SSRC */
2432 rtcpheader
[(len
/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2435 res
= sendto(rtp
->rtcp
->s
, (unsigned int *)rtcpheader
, len
, 0, (struct sockaddr
*)&rtp
->rtcp
->them
, sizeof(rtp
->rtcp
->them
));
2437 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
));
2438 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2442 /* FIXME Don't need to get a new one */
2443 gettimeofday(&rtp
->rtcp
->txlsr
, NULL
);
2444 rtp
->rtcp
->sr_count
++;
2446 rtp
->rtcp
->lastsrtxcount
= rtp
->txcount
;
2448 if (rtcp_debug_test_addr(&rtp
->rtcp
->them
)) {
2449 ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp
->rtcp
->them
.sin_addr
), ntohs(rtp
->rtcp
->them
.sin_port
));
2450 ast_verbose(" Our SSRC: %u\n", rtp
->ssrc
);
2451 ast_verbose(" Sent(NTP): %u.%010u\n", (unsigned int)now
.tv_sec
, (unsigned int)now
.tv_usec
*4096);
2452 ast_verbose(" Sent(RTP): %u\n", rtp
->lastts
);
2453 ast_verbose(" Sent packets: %u\n", rtp
->txcount
);
2454 ast_verbose(" Sent octets: %u\n", rtp
->txoctetcount
);
2455 ast_verbose(" Report block:\n");
2456 ast_verbose(" Fraction lost: %u\n", fraction
);
2457 ast_verbose(" Cumulative loss: %u\n", lost
);
2458 ast_verbose(" IA jitter: %.4f\n", rtp
->rxjitter
);
2459 ast_verbose(" Their last SR: %u\n", rtp
->rtcp
->themrxlsr
);
2460 ast_verbose(" DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader
[12])/65536.0));
2465 /*! \brief Send RTCP recepient's report */
2466 static int ast_rtcp_write_rr(const void *data
)
2468 struct ast_rtp
*rtp
= (struct ast_rtp
*)data
;
2472 unsigned int extended
;
2473 unsigned int expected
;
2474 unsigned int expected_interval
;
2475 unsigned int received_interval
;
2478 unsigned int *rtcpheader
;
2480 struct timeval dlsr
;
2483 if (!rtp
|| !rtp
->rtcp
|| (&rtp
->rtcp
->them
.sin_addr
== 0))
2486 if (!rtp
->rtcp
->them
.sin_addr
.s_addr
) {
2487 ast_log(LOG_ERROR
, "RTCP RR transmission error, rtcp halted\n");
2488 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2492 extended
= rtp
->cycles
+ rtp
->lastrxseqno
;
2493 expected
= extended
- rtp
->seedrxseqno
+ 1;
2494 lost
= expected
- rtp
->rxcount
;
2495 expected_interval
= expected
- rtp
->rtcp
->expected_prior
;
2496 rtp
->rtcp
->expected_prior
= expected
;
2497 received_interval
= rtp
->rxcount
- rtp
->rtcp
->received_prior
;
2498 rtp
->rtcp
->received_prior
= rtp
->rxcount
;
2499 lost_interval
= expected_interval
- received_interval
;
2500 if (expected_interval
== 0 || lost_interval
<= 0)
2503 fraction
= (lost_interval
<< 8) / expected_interval
;
2504 gettimeofday(&now
, NULL
);
2505 timersub(&now
, &rtp
->rtcp
->rxlsr
, &dlsr
);
2506 rtcpheader
= (unsigned int *)bdata
;
2507 rtcpheader
[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR
<< 16) | ((len
/4)-1));
2508 rtcpheader
[1] = htonl(rtp
->ssrc
);
2509 rtcpheader
[2] = htonl(rtp
->themssrc
);
2510 rtcpheader
[3] = htonl(((fraction
& 0xff) << 24) | (lost
& 0xffffff));
2511 rtcpheader
[4] = htonl((rtp
->cycles
) | ((rtp
->lastrxseqno
& 0xffff)));
2512 rtcpheader
[5] = htonl((unsigned int)(rtp
->rxjitter
* 65536.));
2513 rtcpheader
[6] = htonl(rtp
->rtcp
->themrxlsr
);
2514 rtcpheader
[7] = htonl((((dlsr
.tv_sec
* 1000) + (dlsr
.tv_usec
/ 1000)) * 65536) / 1000);
2516 if (rtp
->rtcp
->sendfur
) {
2517 rtcpheader
[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR
<< 16) | 1); /* Header from page 36 in RFC 3550 */
2518 rtcpheader
[9] = htonl(rtp
->ssrc
); /* Our SSRC */
2520 rtp
->rtcp
->sendfur
= 0;
2523 /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos
2524 it can change mid call, and SDES can't) */
2525 rtcpheader
[len
/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES
<< 16) | 2);
2526 rtcpheader
[(len
/4)+1] = htonl(rtp
->ssrc
); /* Our SSRC */
2527 rtcpheader
[(len
/4)+2] = htonl(0x01 << 24); /* Empty for the moment */
2530 res
= sendto(rtp
->rtcp
->s
, (unsigned int *)rtcpheader
, len
, 0, (struct sockaddr
*)&rtp
->rtcp
->them
, sizeof(rtp
->rtcp
->them
));
2533 ast_log(LOG_ERROR
, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno
));
2534 /* Remove the scheduler */
2535 AST_SCHED_DEL(rtp
->sched
, rtp
->rtcp
->schedid
);
2539 rtp
->rtcp
->rr_count
++;
2541 if (rtcp_debug_test_addr(&rtp
->rtcp
->them
)) {
2542 ast_verbose("\n* Sending RTCP RR to %s:%d\n"
2543 " Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n"
2544 " IA jitter: %.4f\n"
2545 " Their last SR: %u\n"
2546 " DLSR: %4.4f (sec)\n\n",
2547 ast_inet_ntoa(rtp
->rtcp
->them
.sin_addr
),
2548 ntohs(rtp
->rtcp
->them
.sin_port
),
2549 rtp
->ssrc
, rtp
->themssrc
, fraction
, lost
,
2551 rtp
->rtcp
->themrxlsr
,
2552 (double)(ntohl(rtcpheader
[7])/65536.0));
2558 /*! \brief Write and RTCP packet to the far end
2559 * \note Decide if we are going to send an SR (with Reception Block) or RR
2560 * RR is sent if we have not sent any rtp packets in the previous interval */
2561 static int ast_rtcp_write(const void *data
)
2563 struct ast_rtp
*rtp
= (struct ast_rtp
*)data
;
2566 if (!rtp
|| !rtp
->rtcp
)
2569 if (rtp
->txcount
> rtp
->rtcp
->lastsrtxcount
)
2570 res
= ast_rtcp_write_sr(data
);
2572 res
= ast_rtcp_write_rr(data
);
2577 /*! \brief generate comfort noice (CNG) */
2578 int ast_rtp_sendcng(struct ast_rtp
*rtp
, int level
)
2580 unsigned int *rtpheader
;
2585 level
= 127 - (level
& 0x7f);
2586 payload
= ast_rtp_lookup_code(rtp
, 0, AST_RTP_CN
);
2588 /* If we have no peer, return immediately */
2589 if (!rtp
->them
.sin_addr
.s_addr
)
2592 rtp
->dtmfmute
= ast_tvadd(ast_tvnow(), ast_tv(0, 500000));
2594 /* Get a pointer to the header */
2595 rtpheader
= (unsigned int *)data
;
2596 rtpheader
[0] = htonl((2 << 30) | (1 << 23) | (payload
<< 16) | (rtp
->seqno
++));
2597 rtpheader
[1] = htonl(rtp
->lastts
);
2598 rtpheader
[2] = htonl(rtp
->ssrc
);
2600 if (rtp
->them
.sin_port
&& rtp
->them
.sin_addr
.s_addr
) {
2601 res
= sendto(rtp
->s
, (void *)rtpheader
, hdrlen
+ 1, 0, (struct sockaddr
*)&rtp
->them
, sizeof(rtp
->them
));
2603 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
));
2604 if (rtp_debug_test_addr(&rtp
->them
))
2605 ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n"
2606 , ast_inet_ntoa(rtp
->them
.sin_addr
), ntohs(rtp
->them
.sin_port
), payload
, rtp
->seqno
, rtp
->lastts
,res
- hdrlen
);
2612 static int ast_rtp_raw_write(struct ast_rtp
*rtp
, struct ast_frame
*f
, int codec
)
2614 unsigned char *rtpheader
;
2621 ms
= calc_txstamp(rtp
, &f
->delivery
);
2622 /* Default prediction */
2623 if (f
->frametype
== AST_FRAME_VOICE
) {
2624 pred
= rtp
->lastts
+ f
->samples
;
2626 /* Re-calculate last TS */
2627 rtp
->lastts
= rtp
->lastts
+ ms
* 8;
2628 if (ast_tvzero(f
->delivery
)) {
2629 /* If this isn't an absolute delivery time, Check if it is close to our prediction,
2630 and if so, go with our prediction */
2631 if (abs(rtp
->lastts
- pred
) < MAX_TIMESTAMP_SKEW
)
2634 if (option_debug
> 2)
2635 ast_log(LOG_DEBUG
, "Difference is %d, ms is %d\n", abs(rtp
->lastts
- pred
), ms
);
2639 } else if (f
->frametype
== AST_FRAME_VIDEO
) {
2640 mark
= f
->subclass
& 0x1;
2641 pred
= rtp
->lastovidtimestamp
+ f
->samples
;
2642 /* Re-calculate last TS */
2643 rtp
->lastts
= rtp
->lastts
+ ms
* 90;
2644 /* If it's close to our prediction, go for it */
2645 if (ast_tvzero(f
->delivery
)) {
2646 if (abs(rtp
->lastts
- pred
) < 7200) {
2648 rtp
->lastovidtimestamp
+= f
->samples
;
2650 if (option_debug
> 2)
2651 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
);
2652 rtp
->lastovidtimestamp
= rtp
->lastts
;
2657 /* If we have been explicitly told to set the marker bit do so */
2658 if (rtp
->set_marker_bit
) {
2660 rtp
->set_marker_bit
= 0;
2663 /* If the timestamp for non-digit packets has moved beyond the timestamp
2664 for digits, update the digit timestamp.
2666 if (rtp
->lastts
> rtp
->lastdigitts
)
2667 rtp
->lastdigitts
= rtp
->lastts
;
2669 if (ast_test_flag(f
, AST_FRFLAG_HAS_TIMING_INFO
))
2670 rtp
->lastts
= f
->ts
* 8;
2672 /* Get a pointer to the header */
2673 rtpheader
= (unsigned char *)(f
->data
- hdrlen
);
2675 put_unaligned_uint32(rtpheader
, htonl((2 << 30) | (codec
<< 16) | (rtp
->seqno
) | (mark
<< 23)));
2676 put_unaligned_uint32(rtpheader
+ 4, htonl(rtp
->lastts
));
2677 put_unaligned_uint32(rtpheader
+ 8, htonl(rtp
->ssrc
));
2679 if (rtp
->them
.sin_port
&& rtp
->them
.sin_addr
.s_addr
) {
2680 res
= sendto(rtp
->s
, (void *)rtpheader
, f
->datalen
+ hdrlen
, 0, (struct sockaddr
*)&rtp
->them
, sizeof(rtp
->them
));
2682 if (!rtp
->nat
|| (rtp
->nat
&& (ast_test_flag(rtp
, FLAG_NAT_ACTIVE
) == FLAG_NAT_ACTIVE
))) {
2683 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
));
2684 } else if (((ast_test_flag(rtp
, FLAG_NAT_ACTIVE
) == FLAG_NAT_INACTIVE
) || rtpdebug
) && !ast_test_flag(rtp
, FLAG_NAT_INACTIVE_NOWARN
)) {
2685 /* Only give this error message once if we are not RTP debugging */
2686 if (option_debug
|| rtpdebug
)
2687 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
));
2688 ast_set_flag(rtp
, FLAG_NAT_INACTIVE_NOWARN
);
2692 rtp
->txoctetcount
+=(res
- hdrlen
);
2694 if (rtp
->rtcp
&& rtp
->rtcp
->schedid
< 1)
2695 rtp
->rtcp
->schedid
= ast_sched_add(rtp
->sched
, ast_rtcp_calc_interval(rtp
), ast_rtcp_write
, rtp
);
2698 if (rtp_debug_test_addr(&rtp
->them
))
2699 ast_verbose("Sent RTP packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n",
2700 ast_inet_ntoa(rtp
->them
.sin_addr
), ntohs(rtp
->them
.sin_port
), codec
, rtp
->seqno
, rtp
->lastts
,res
- hdrlen
);
2708 int ast_rtp_codec_setpref(struct ast_rtp
*rtp
, struct ast_codec_pref
*prefs
)
2711 for (x
= 0; x
< 32; x
++) { /* Ugly way */
2712 rtp
->pref
.order
[x
] = prefs
->order
[x
];
2713 rtp
->pref
.framing
[x
] = prefs
->framing
[x
];
2716 ast_smoother_free(rtp
->smoother
);
2717 rtp
->smoother
= NULL
;
2721 struct ast_codec_pref
*ast_rtp_codec_getpref(struct ast_rtp
*rtp
)
2726 int ast_rtp_codec_getformat(int pt
)
2728 if (pt
< 0 || pt
> MAX_RTP_PT
)
2729 return 0; /* bogus payload type */
2731 if (static_RTP_PT
[pt
].isAstFormat
)
2732 return static_RTP_PT
[pt
].code
;
2737 int ast_rtp_write(struct ast_rtp
*rtp
, struct ast_frame
*_f
)
2739 struct ast_frame
*f
;
2745 /* If we have no peer, return immediately */
2746 if (!rtp
->them
.sin_addr
.s_addr
)
2749 /* If there is no data length, return immediately */
2753 /* Make sure we have enough space for RTP header */
2754 if ((_f
->frametype
!= AST_FRAME_VOICE
) && (_f
->frametype
!= AST_FRAME_VIDEO
)) {
2755 ast_log(LOG_WARNING
, "RTP can only send voice and video\n");
2759 subclass
= _f
->subclass
;
2760 if (_f
->frametype
== AST_FRAME_VIDEO
)
2763 codec
= ast_rtp_lookup_code(rtp
, 1, subclass
);
2765 ast_log(LOG_WARNING
, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f
->subclass
));
2769 if (rtp
->lasttxformat
!= subclass
) {
2770 /* New format, reset the smoother */
2772 ast_log(LOG_DEBUG
, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp
->lasttxformat
), ast_getformatname(subclass
));
2773 rtp
->lasttxformat
= subclass
;
2775 ast_smoother_free(rtp
->smoother
);
2776 rtp
->smoother
= NULL
;
2779 if (!rtp
->smoother
&& subclass
!= AST_FORMAT_SPEEX
&& subclass
!= AST_FORMAT_G723_1
) {
2780 struct ast_format_list fmt
= ast_codec_pref_getsize(&rtp
->pref
, subclass
);
2781 if (fmt
.inc_ms
) { /* if codec parameters is set / avoid division by zero */
2782 if (!(rtp
->smoother
= ast_smoother_new((fmt
.cur_ms
* fmt
.fr_len
) / fmt
.inc_ms
))) {
2783 ast_log(LOG_WARNING
, "Unable to create smoother: format: %d ms: %d len: %d\n", subclass
, fmt
.cur_ms
, ((fmt
.cur_ms
* fmt
.fr_len
) / fmt
.inc_ms
));
2787 ast_smoother_set_flags(rtp
->smoother
, fmt
.flags
);
2789 ast_log(LOG_DEBUG
, "Created smoother: format: %d ms: %d len: %d\n", subclass
, fmt
.cur_ms
, ((fmt
.cur_ms
* fmt
.fr_len
) / fmt
.inc_ms
));
2792 if (rtp
->smoother
) {
2793 if (ast_smoother_test_flag(rtp
->smoother
, AST_SMOOTHER_FLAG_BE
)) {
2794 ast_smoother_feed_be(rtp
->smoother
, _f
);
2796 ast_smoother_feed(rtp
->smoother
, _f
);
2799 while((f
= ast_smoother_read(rtp
->smoother
)) && (f
->data
))
2800 ast_rtp_raw_write(rtp
, f
, codec
);
2802 /* Don't buffer outgoing frames; send them one-per-packet: */
2803 if (_f
->offset
< hdrlen
) {
2809 ast_rtp_raw_write(rtp
, f
, codec
);
2817 /*! \brief Unregister interface to channel driver */
2818 void ast_rtp_proto_unregister(struct ast_rtp_protocol
*proto
)
2820 AST_LIST_LOCK(&protos
);
2821 AST_LIST_REMOVE(&protos
, proto
, list
);
2822 AST_LIST_UNLOCK(&protos
);
2825 /*! \brief Register interface to channel driver */
2826 int ast_rtp_proto_register(struct ast_rtp_protocol
*proto
)
2828 struct ast_rtp_protocol
*cur
;
2830 AST_LIST_LOCK(&protos
);
2831 AST_LIST_TRAVERSE(&protos
, cur
, list
) {
2832 if (!strcmp(cur
->type
, proto
->type
)) {
2833 ast_log(LOG_WARNING
, "Tried to register same protocol '%s' twice\n", cur
->type
);
2834 AST_LIST_UNLOCK(&protos
);
2838 AST_LIST_INSERT_HEAD(&protos
, proto
, list
);
2839 AST_LIST_UNLOCK(&protos
);
2844 /*! \brief Bridge loop for true native bridge (reinvite) */
2845 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
)
2847 struct ast_frame
*fr
= NULL
;
2848 struct ast_channel
*who
= NULL
, *other
= NULL
, *cs
[3] = {NULL
, };
2849 int oldcodec0
= codec0
, oldcodec1
= codec1
;
2850 struct sockaddr_in ac1
= {0,}, vac1
= {0,}, ac0
= {0,}, vac0
= {0,};
2851 struct sockaddr_in t1
= {0,}, vt1
= {0,}, t0
= {0,}, vt0
= {0,};
2853 /* Set it up so audio goes directly between the two endpoints */
2855 /* Test the first channel */
2856 if (!(pr0
->set_rtp_peer(c0
, p1
, vp1
, codec1
, ast_test_flag(p1
, FLAG_NAT_ACTIVE
)))) {
2857 ast_rtp_get_peer(p1
, &ac1
);
2859 ast_rtp_get_peer(vp1
, &vac1
);
2861 ast_log(LOG_WARNING
, "Channel '%s' failed to talk to '%s'\n", c0
->name
, c1
->name
);
2863 /* Test the second channel */
2864 if (!(pr1
->set_rtp_peer(c1
, p0
, vp0
, codec0
, ast_test_flag(p0
, FLAG_NAT_ACTIVE
)))) {
2865 ast_rtp_get_peer(p0
, &ac0
);
2867 ast_rtp_get_peer(vp0
, &vac0
);
2869 ast_log(LOG_WARNING
, "Channel '%s' failed to talk to '%s'\n", c1
->name
, c0
->name
);
2871 /* Now we can unlock and move into our loop */
2872 ast_channel_unlock(c0
);
2873 ast_channel_unlock(c1
);
2875 /* Throw our channels into the structure and enter the loop */
2880 /* Check if anything changed */
2881 if ((c0
->tech_pvt
!= pvt0
) ||
2882 (c1
->tech_pvt
!= pvt1
) ||
2883 (c0
->masq
|| c0
->masqr
|| c1
->masq
|| c1
->masqr
) ||
2884 (c0
->monitor
|| c0
->audiohooks
|| c1
->monitor
|| c1
->audiohooks
)) {
2885 ast_log(LOG_DEBUG
, "Oooh, something is weird, backing out\n");
2886 if (c0
->tech_pvt
== pvt0
)
2887 if (pr0
->set_rtp_peer(c0
, NULL
, NULL
, 0, 0))
2888 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c0
->name
);
2889 if (c1
->tech_pvt
== pvt1
)
2890 if (pr1
->set_rtp_peer(c1
, NULL
, NULL
, 0, 0))
2891 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c1
->name
);
2892 return AST_BRIDGE_RETRY
;
2895 /* Check if they have changed their address */
2896 ast_rtp_get_peer(p1
, &t1
);
2898 ast_rtp_get_peer(vp1
, &vt1
);
2900 codec1
= pr1
->get_codec(c1
);
2901 ast_rtp_get_peer(p0
, &t0
);
2903 ast_rtp_get_peer(vp0
, &vt0
);
2905 codec0
= pr0
->get_codec(c0
);
2906 if ((inaddrcmp(&t1
, &ac1
)) ||
2907 (vp1
&& inaddrcmp(&vt1
, &vac1
)) ||
2908 (codec1
!= oldcodec1
)) {
2909 if (option_debug
> 1) {
2910 ast_log(LOG_DEBUG
, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2911 c1
->name
, ast_inet_ntoa(t1
.sin_addr
), ntohs(t1
.sin_port
), codec1
);
2912 ast_log(LOG_DEBUG
, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
2913 c1
->name
, ast_inet_ntoa(vt1
.sin_addr
), ntohs(vt1
.sin_port
), codec1
);
2914 ast_log(LOG_DEBUG
, "Oooh, '%s' was %s:%d/(format %d)\n",
2915 c1
->name
, ast_inet_ntoa(ac1
.sin_addr
), ntohs(ac1
.sin_port
), oldcodec1
);
2916 ast_log(LOG_DEBUG
, "Oooh, '%s' was %s:%d/(format %d)\n",
2917 c1
->name
, ast_inet_ntoa(vac1
.sin_addr
), ntohs(vac1
.sin_port
), oldcodec1
);
2919 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
)))
2920 ast_log(LOG_WARNING
, "Channel '%s' failed to update to '%s'\n", c0
->name
, c1
->name
);
2921 memcpy(&ac1
, &t1
, sizeof(ac1
));
2922 memcpy(&vac1
, &vt1
, sizeof(vac1
));
2925 if ((inaddrcmp(&t0
, &ac0
)) ||
2926 (vp0
&& inaddrcmp(&vt0
, &vac0
))) {
2927 if (option_debug
> 1) {
2928 ast_log(LOG_DEBUG
, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
2929 c0
->name
, ast_inet_ntoa(t0
.sin_addr
), ntohs(t0
.sin_port
), codec0
);
2930 ast_log(LOG_DEBUG
, "Oooh, '%s' was %s:%d/(format %d)\n",
2931 c0
->name
, ast_inet_ntoa(ac0
.sin_addr
), ntohs(ac0
.sin_port
), oldcodec0
);
2933 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
)))
2934 ast_log(LOG_WARNING
, "Channel '%s' failed to update to '%s'\n", c1
->name
, c0
->name
);
2935 memcpy(&ac0
, &t0
, sizeof(ac0
));
2936 memcpy(&vac0
, &vt0
, sizeof(vac0
));
2940 /* Wait for frame to come in on the channels */
2941 if (!(who
= ast_waitfor_n(cs
, 2, &timeoutms
))) {
2943 if (pr0
->set_rtp_peer(c0
, NULL
, NULL
, 0, 0))
2944 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c0
->name
);
2945 if (pr1
->set_rtp_peer(c1
, NULL
, NULL
, 0, 0))
2946 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c1
->name
);
2947 return AST_BRIDGE_RETRY
;
2950 ast_log(LOG_DEBUG
, "Ooh, empty read...\n");
2951 if (ast_check_hangup(c0
) || ast_check_hangup(c1
))
2956 other
= (who
== c0
) ? c1
: c0
;
2957 if (!fr
|| ((fr
->frametype
== AST_FRAME_DTMF_BEGIN
|| fr
->frametype
== AST_FRAME_DTMF_END
) &&
2958 (((who
== c0
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_0
)) ||
2959 ((who
== c1
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_1
))))) {
2960 /* Break out of bridge */
2964 ast_log(LOG_DEBUG
, "Oooh, got a %s\n", fr
? "digit" : "hangup");
2965 if (c0
->tech_pvt
== pvt0
)
2966 if (pr0
->set_rtp_peer(c0
, NULL
, NULL
, 0, 0))
2967 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c0
->name
);
2968 if (c1
->tech_pvt
== pvt1
)
2969 if (pr1
->set_rtp_peer(c1
, NULL
, NULL
, 0, 0))
2970 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c1
->name
);
2971 return AST_BRIDGE_COMPLETE
;
2972 } else if ((fr
->frametype
== AST_FRAME_CONTROL
) && !(flags
& AST_BRIDGE_IGNORE_SIGS
)) {
2973 if ((fr
->subclass
== AST_CONTROL_HOLD
) ||
2974 (fr
->subclass
== AST_CONTROL_UNHOLD
) ||
2975 (fr
->subclass
== AST_CONTROL_VIDUPDATE
) ||
2976 (fr
->subclass
== AST_CONTROL_SRCUPDATE
)) {
2977 if (fr
->subclass
== AST_CONTROL_HOLD
) {
2978 /* If we someone went on hold we want the other side to reinvite back to us */
2980 pr1
->set_rtp_peer(c1
, NULL
, NULL
, 0, 0);
2982 pr0
->set_rtp_peer(c0
, NULL
, NULL
, 0, 0);
2983 } else if (fr
->subclass
== AST_CONTROL_UNHOLD
) {
2984 /* If they went off hold they should go back to being direct */
2986 pr1
->set_rtp_peer(c1
, p0
, vp0
, codec0
, ast_test_flag(p0
, FLAG_NAT_ACTIVE
));
2988 pr0
->set_rtp_peer(c0
, p1
, vp1
, codec1
, ast_test_flag(p1
, FLAG_NAT_ACTIVE
));
2990 /* Update local address information */
2991 ast_rtp_get_peer(p0
, &t0
);
2992 memcpy(&ac0
, &t0
, sizeof(ac0
));
2993 ast_rtp_get_peer(p1
, &t1
);
2994 memcpy(&ac1
, &t1
, sizeof(ac1
));
2995 /* Update codec information */
2996 if (pr0
->get_codec
&& c0
->tech_pvt
)
2997 oldcodec0
= codec0
= pr0
->get_codec(c0
);
2998 if (pr1
->get_codec
&& c1
->tech_pvt
)
2999 oldcodec1
= codec1
= pr1
->get_codec(c1
);
3000 ast_indicate_data(other
, fr
->subclass
, fr
->data
, fr
->datalen
);
3005 ast_log(LOG_DEBUG
, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr
->subclass
, who
->name
);
3006 return AST_BRIDGE_COMPLETE
;
3009 if ((fr
->frametype
== AST_FRAME_DTMF_BEGIN
) ||
3010 (fr
->frametype
== AST_FRAME_DTMF_END
) ||
3011 (fr
->frametype
== AST_FRAME_VOICE
) ||
3012 (fr
->frametype
== AST_FRAME_VIDEO
) ||
3013 (fr
->frametype
== AST_FRAME_IMAGE
) ||
3014 (fr
->frametype
== AST_FRAME_HTML
) ||
3015 (fr
->frametype
== AST_FRAME_MODEM
) ||
3016 (fr
->frametype
== AST_FRAME_TEXT
)) {
3017 ast_write(other
, fr
);
3027 if (pr0
->set_rtp_peer(c0
, NULL
, NULL
, 0, 0))
3028 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c0
->name
);
3029 if (pr1
->set_rtp_peer(c1
, NULL
, NULL
, 0, 0))
3030 ast_log(LOG_WARNING
, "Channel '%s' failed to break RTP bridge\n", c1
->name
);
3032 return AST_BRIDGE_FAILED
;
3035 /*! \brief P2P RTP Callback */
3037 static int p2p_rtp_callback(int *id
, int fd
, short events
, void *cbdata
)
3039 int res
= 0, hdrlen
= 12;
3040 struct sockaddr_in sin
;
3042 unsigned int *header
;
3043 struct ast_rtp
*rtp
= cbdata
, *bridged
= NULL
;
3049 if ((res
= recvfrom(fd
, rtp
->rawdata
+ AST_FRIENDLY_OFFSET
, sizeof(rtp
->rawdata
) - AST_FRIENDLY_OFFSET
, 0, (struct sockaddr
*)&sin
, &len
)) < 0)
3052 header
= (unsigned int *)(rtp
->rawdata
+ AST_FRIENDLY_OFFSET
);
3054 /* If NAT support is turned on, then see if we need to change their address */
3056 ((rtp
->them
.sin_addr
.s_addr
!= sin
.sin_addr
.s_addr
) ||
3057 (rtp
->them
.sin_port
!= sin
.sin_port
))) {
3060 ast_set_flag(rtp
, FLAG_NAT_ACTIVE
);
3061 if (option_debug
|| rtpdebug
)
3062 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
));
3065 /* Write directly out to other RTP stream if bridged */
3066 if ((bridged
= ast_rtp_get_bridged(rtp
)))
3067 bridge_p2p_rtp_write(rtp
, bridged
, header
, res
, hdrlen
);
3072 /*! \brief Helper function to switch a channel and RTP stream into callback mode */
3073 static int p2p_callback_enable(struct ast_channel
*chan
, struct ast_rtp
*rtp
, int *fds
, int **iod
)
3075 /* If we need DTMF, are looking for STUN, or we have no IO structure then we can't do direct callback */
3076 if (ast_test_flag(rtp
, FLAG_P2P_NEED_DTMF
) || ast_test_flag(rtp
, FLAG_HAS_STUN
) || !rtp
->io
)
3079 /* If the RTP structure is already in callback mode, remove it temporarily */
3081 ast_io_remove(rtp
->io
, rtp
->ioid
);
3085 /* Steal the file descriptors from the channel and stash them away */
3086 fds
[0] = chan
->fds
[0];
3089 /* Now, fire up callback mode */
3090 iod
[0] = ast_io_add(rtp
->io
, fds
[0], p2p_rtp_callback
, AST_IO_IN
, rtp
);
3095 static int p2p_callback_enable(struct ast_channel
*chan
, struct ast_rtp
*rtp
, int *fds
, int **iod
)
3101 /*! \brief Helper function to switch a channel and RTP stream out of callback mode */
3102 static int p2p_callback_disable(struct ast_channel
*chan
, struct ast_rtp
*rtp
, int *fds
, int **iod
)
3104 ast_channel_lock(chan
);
3106 /* Remove the callback from the IO context */
3107 ast_io_remove(rtp
->io
, iod
[0]);
3109 /* Restore file descriptors */
3110 chan
->fds
[0] = fds
[0];
3111 ast_channel_unlock(chan
);
3113 /* Restore callback mode if previously used */
3114 if (ast_test_flag(rtp
, FLAG_CALLBACK_MODE
))
3115 rtp
->ioid
= ast_io_add(rtp
->io
, rtp
->s
, rtpread
, AST_IO_IN
, rtp
);
3120 /*! \brief Helper function that sets what an RTP structure is bridged to */
3121 static void p2p_set_bridge(struct ast_rtp
*rtp0
, struct ast_rtp
*rtp1
)
3123 ast_mutex_lock(&rtp0
->bridge_lock
);
3124 rtp0
->bridged
= rtp1
;
3125 ast_mutex_unlock(&rtp0
->bridge_lock
);
3130 /*! \brief Bridge loop for partial native bridge (packet2packet) */
3131 static enum ast_bridge_result
bridge_p2p_loop(struct ast_channel
*c0
, struct ast_channel
*c1
, struct ast_rtp
*p0
, struct ast_rtp
*p1
, int timeoutms
, int flags
, struct ast_frame
**fo
, struct ast_channel
**rc
, void *pvt0
, void *pvt1
)
3133 struct ast_frame
*fr
= NULL
;
3134 struct ast_channel
*who
= NULL
, *other
= NULL
, *cs
[3] = {NULL
, };
3135 int p0_fds
[2] = {-1, -1}, p1_fds
[2] = {-1, -1};
3136 int *p0_iod
[2] = {NULL
, NULL
}, *p1_iod
[2] = {NULL
, NULL
};
3137 int p0_callback
= 0, p1_callback
= 0;
3138 enum ast_bridge_result res
= AST_BRIDGE_FAILED
;
3140 /* Okay, setup each RTP structure to do P2P forwarding */
3141 ast_clear_flag(p0
, FLAG_P2P_SENT_MARK
);
3142 p2p_set_bridge(p0
, p1
);
3143 ast_clear_flag(p1
, FLAG_P2P_SENT_MARK
);
3144 p2p_set_bridge(p1
, p0
);
3146 /* Activate callback modes if possible */
3147 p0_callback
= p2p_callback_enable(c0
, p0
, &p0_fds
[0], &p0_iod
[0]);
3148 p1_callback
= p2p_callback_enable(c1
, p1
, &p1_fds
[0], &p1_iod
[0]);
3150 /* Now let go of the channel locks and be on our way */
3151 ast_channel_unlock(c0
);
3152 ast_channel_unlock(c1
);
3154 /* Go into a loop forwarding frames until we don't need to anymore */
3159 /* If the underlying formats have changed force this bridge to break */
3160 if ((c0
->rawreadformat
!= c1
->rawwriteformat
) || (c1
->rawreadformat
!= c0
->rawwriteformat
)) {
3161 ast_log(LOG_DEBUG
, "Oooh, formats changed, backing out\n");
3162 res
= AST_BRIDGE_FAILED_NOWARN
;
3165 /* Check if anything changed */
3166 if ((c0
->tech_pvt
!= pvt0
) ||
3167 (c1
->tech_pvt
!= pvt1
) ||
3168 (c0
->masq
|| c0
->masqr
|| c1
->masq
|| c1
->masqr
) ||
3169 (c0
->monitor
|| c0
->audiohooks
|| c1
->monitor
|| c1
->audiohooks
)) {
3170 ast_log(LOG_DEBUG
, "Oooh, something is weird, backing out\n");
3171 if ((c0
->masq
|| c0
->masqr
) && (fr
= ast_read(c0
)))
3173 if ((c1
->masq
|| c1
->masqr
) && (fr
= ast_read(c1
)))
3175 res
= AST_BRIDGE_RETRY
;
3178 /* Wait on a channel to feed us a frame */
3179 if (!(who
= ast_waitfor_n(cs
, 2, &timeoutms
))) {
3181 res
= AST_BRIDGE_RETRY
;
3185 ast_log(LOG_NOTICE
, "Ooh, empty read...\n");
3186 if (ast_check_hangup(c0
) || ast_check_hangup(c1
))
3190 /* Read in frame from channel */
3192 other
= (who
== c0
) ? c1
: c0
;
3193 /* Dependong on the frame we may need to break out of our bridge */
3194 if (!fr
|| ((fr
->frametype
== AST_FRAME_DTMF_BEGIN
|| fr
->frametype
== AST_FRAME_DTMF_END
) &&
3195 ((who
== c0
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_0
)) |
3196 ((who
== c1
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_1
)))) {
3197 /* Record received frame and who */
3201 ast_log(LOG_DEBUG
, "Oooh, got a %s\n", fr
? "digit" : "hangup");
3202 res
= AST_BRIDGE_COMPLETE
;
3204 } else if ((fr
->frametype
== AST_FRAME_CONTROL
) && !(flags
& AST_BRIDGE_IGNORE_SIGS
)) {
3205 if ((fr
->subclass
== AST_CONTROL_HOLD
) ||
3206 (fr
->subclass
== AST_CONTROL_UNHOLD
) ||
3207 (fr
->subclass
== AST_CONTROL_VIDUPDATE
) ||
3208 (fr
->subclass
== AST_CONTROL_SRCUPDATE
)) {
3209 /* If we are going on hold, then break callback mode and P2P bridging */
3210 if (fr
->subclass
== AST_CONTROL_HOLD
) {
3212 p0_callback
= p2p_callback_disable(c0
, p0
, &p0_fds
[0], &p0_iod
[0]);
3214 p1_callback
= p2p_callback_disable(c1
, p1
, &p1_fds
[0], &p1_iod
[0]);
3215 p2p_set_bridge(p0
, NULL
);
3216 p2p_set_bridge(p1
, NULL
);
3217 } else if (fr
->subclass
== AST_CONTROL_UNHOLD
) {
3218 /* If we are off hold, then go back to callback mode and P2P bridging */
3219 ast_clear_flag(p0
, FLAG_P2P_SENT_MARK
);
3220 p2p_set_bridge(p0
, p1
);
3221 ast_clear_flag(p1
, FLAG_P2P_SENT_MARK
);
3222 p2p_set_bridge(p1
, p0
);
3223 p0_callback
= p2p_callback_enable(c0
, p0
, &p0_fds
[0], &p0_iod
[0]);
3224 p1_callback
= p2p_callback_enable(c1
, p1
, &p1_fds
[0], &p1_iod
[0]);
3226 ast_indicate_data(other
, fr
->subclass
, fr
->data
, fr
->datalen
);
3231 ast_log(LOG_DEBUG
, "Got a FRAME_CONTROL (%d) frame on channel %s\n", fr
->subclass
, who
->name
);
3232 res
= AST_BRIDGE_COMPLETE
;
3236 if ((fr
->frametype
== AST_FRAME_DTMF_BEGIN
) ||
3237 (fr
->frametype
== AST_FRAME_DTMF_END
) ||
3238 (fr
->frametype
== AST_FRAME_VOICE
) ||
3239 (fr
->frametype
== AST_FRAME_VIDEO
) ||
3240 (fr
->frametype
== AST_FRAME_IMAGE
) ||
3241 (fr
->frametype
== AST_FRAME_HTML
) ||
3242 (fr
->frametype
== AST_FRAME_MODEM
) ||
3243 (fr
->frametype
== AST_FRAME_TEXT
)) {
3244 ast_write(other
, fr
);
3255 /* If we are totally avoiding the core, then restore our link to it */
3257 p0_callback
= p2p_callback_disable(c0
, p0
, &p0_fds
[0], &p0_iod
[0]);
3259 p1_callback
= p2p_callback_disable(c1
, p1
, &p1_fds
[0], &p1_iod
[0]);
3261 /* Break out of the direct bridge */
3262 p2p_set_bridge(p0
, NULL
);
3263 p2p_set_bridge(p1
, NULL
);
3268 /*! \brief Bridge calls. If possible and allowed, initiate
3269 re-invite so the peers exchange media directly outside
3271 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
)
3273 struct ast_rtp
*p0
= NULL
, *p1
= NULL
; /* Audio RTP Channels */
3274 struct ast_rtp
*vp0
= NULL
, *vp1
= NULL
; /* Video RTP channels */
3275 struct ast_rtp_protocol
*pr0
= NULL
, *pr1
= NULL
;
3276 enum ast_rtp_get_result audio_p0_res
= AST_RTP_GET_FAILED
, video_p0_res
= AST_RTP_GET_FAILED
;
3277 enum ast_rtp_get_result audio_p1_res
= AST_RTP_GET_FAILED
, video_p1_res
= AST_RTP_GET_FAILED
;
3278 enum ast_bridge_result res
= AST_BRIDGE_FAILED
;
3279 int codec0
= 0, codec1
= 0;
3280 void *pvt0
= NULL
, *pvt1
= NULL
;
3283 ast_channel_lock(c0
);
3284 while(ast_channel_trylock(c1
)) {
3285 ast_channel_unlock(c0
);
3287 ast_channel_lock(c0
);
3290 /* Ensure neither channel got hungup during lock avoidance */
3291 if (ast_check_hangup(c0
) || ast_check_hangup(c1
)) {
3292 ast_log(LOG_WARNING
, "Got hangup while attempting to bridge '%s' and '%s'\n", c0
->name
, c1
->name
);
3293 ast_channel_unlock(c0
);
3294 ast_channel_unlock(c1
);
3295 return AST_BRIDGE_FAILED
;
3298 /* Find channel driver interfaces */
3299 if (!(pr0
= get_proto(c0
))) {
3300 ast_log(LOG_WARNING
, "Can't find native functions for channel '%s'\n", c0
->name
);
3301 ast_channel_unlock(c0
);
3302 ast_channel_unlock(c1
);
3303 return AST_BRIDGE_FAILED
;
3305 if (!(pr1
= get_proto(c1
))) {
3306 ast_log(LOG_WARNING
, "Can't find native functions for channel '%s'\n", c1
->name
);
3307 ast_channel_unlock(c0
);
3308 ast_channel_unlock(c1
);
3309 return AST_BRIDGE_FAILED
;
3312 /* Get channel specific interface structures */
3313 pvt0
= c0
->tech_pvt
;
3314 pvt1
= c1
->tech_pvt
;
3316 /* Get audio and video interface (if native bridge is possible) */
3317 audio_p0_res
= pr0
->get_rtp_info(c0
, &p0
);
3318 video_p0_res
= pr0
->get_vrtp_info
? pr0
->get_vrtp_info(c0
, &vp0
) : AST_RTP_GET_FAILED
;
3319 audio_p1_res
= pr1
->get_rtp_info(c1
, &p1
);
3320 video_p1_res
= pr1
->get_vrtp_info
? pr1
->get_vrtp_info(c1
, &vp1
) : AST_RTP_GET_FAILED
;
3322 /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */
3323 if (video_p0_res
!= AST_RTP_GET_FAILED
&& (audio_p0_res
!= AST_RTP_TRY_NATIVE
|| video_p0_res
!= AST_RTP_TRY_NATIVE
))
3324 audio_p0_res
= AST_RTP_GET_FAILED
;
3325 if (video_p1_res
!= AST_RTP_GET_FAILED
&& (audio_p1_res
!= AST_RTP_TRY_NATIVE
|| video_p1_res
!= AST_RTP_TRY_NATIVE
))
3326 audio_p1_res
= AST_RTP_GET_FAILED
;
3328 /* Check if a bridge is possible (partial/native) */
3329 if (audio_p0_res
== AST_RTP_GET_FAILED
|| audio_p1_res
== AST_RTP_GET_FAILED
) {
3330 /* Somebody doesn't want to play... */
3331 ast_channel_unlock(c0
);
3332 ast_channel_unlock(c1
);
3333 return AST_BRIDGE_FAILED_NOWARN
;
3336 /* If we need to feed DTMF frames into the core then only do a partial native bridge */
3337 if (ast_test_flag(p0
, FLAG_HAS_DTMF
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_0
)) {
3338 ast_set_flag(p0
, FLAG_P2P_NEED_DTMF
);
3339 audio_p0_res
= AST_RTP_TRY_PARTIAL
;
3342 if (ast_test_flag(p1
, FLAG_HAS_DTMF
) && (flags
& AST_BRIDGE_DTMF_CHANNEL_1
)) {
3343 ast_set_flag(p1
, FLAG_P2P_NEED_DTMF
);
3344 audio_p1_res
= AST_RTP_TRY_PARTIAL
;
3347 /* If both sides are not using the same method of DTMF transmission
3348 * (ie: one is RFC2833, other is INFO... then we can not do direct media.
3349 * --------------------------------------------------
3350 * | DTMF Mode | HAS_DTMF | Accepts Begin Frames |
3351 * |-----------|------------|-----------------------|
3352 * | Inband | False | True |
3353 * | RFC2833 | True | True |
3354 * | SIP INFO | False | False |
3355 * --------------------------------------------------
3356 * However, if DTMF from both channels is being monitored by the core, then
3357 * we can still do packet-to-packet bridging, because passing through the
3358 * core will handle DTMF mode translation.
3360 if ( (ast_test_flag(p0
, FLAG_HAS_DTMF
) != ast_test_flag(p1
, FLAG_HAS_DTMF
)) ||
3361 (!c0
->tech
->send_digit_begin
!= !c1
->tech
->send_digit_begin
)) {
3362 if (!ast_test_flag(p0
, FLAG_P2P_NEED_DTMF
) || !ast_test_flag(p1
, FLAG_P2P_NEED_DTMF
)) {
3363 ast_channel_unlock(c0
);
3364 ast_channel_unlock(c1
);
3365 return AST_BRIDGE_FAILED_NOWARN
;
3367 audio_p0_res
= AST_RTP_TRY_PARTIAL
;
3368 audio_p1_res
= AST_RTP_TRY_PARTIAL
;
3371 /* If the core will need to compensate and the P2P bridge will need to feed up DTMF frames then we can not reliably do so yet, so do not P2P bridge */
3372 if ((audio_p0_res
== AST_RTP_TRY_PARTIAL
&& ast_test_flag(p0
, FLAG_P2P_NEED_DTMF
) && ast_test_flag(p0
, FLAG_DTMF_COMPENSATE
)) ||
3373 (audio_p1_res
== AST_RTP_TRY_PARTIAL
&& ast_test_flag(p1
, FLAG_P2P_NEED_DTMF
) && ast_test_flag(p1
, FLAG_DTMF_COMPENSATE
))) {
3374 ast_channel_unlock(c0
);
3375 ast_channel_unlock(c1
);
3376 return AST_BRIDGE_FAILED_NOWARN
;
3379 /* Get codecs from both sides */
3380 codec0
= pr0
->get_codec
? pr0
->get_codec(c0
) : 0;
3381 codec1
= pr1
->get_codec
? pr1
->get_codec(c1
) : 0;
3382 if (codec0
&& codec1
&& !(codec0
& codec1
)) {
3383 /* Hey, we can't do native bridging if both parties speak different codecs */
3385 ast_log(LOG_DEBUG
, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0
, codec1
);
3386 ast_channel_unlock(c0
);
3387 ast_channel_unlock(c1
);
3388 return AST_BRIDGE_FAILED_NOWARN
;
3391 /* If either side can only do a partial bridge, then don't try for a true native bridge */
3392 if (audio_p0_res
== AST_RTP_TRY_PARTIAL
|| audio_p1_res
== AST_RTP_TRY_PARTIAL
) {
3393 struct ast_format_list fmt0
, fmt1
;
3395 /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */
3396 if (c0
->rawreadformat
!= c1
->rawwriteformat
|| c1
->rawreadformat
!= c0
->rawwriteformat
) {
3398 ast_log(LOG_DEBUG
, "Cannot packet2packet bridge - raw formats are incompatible\n");
3399 ast_channel_unlock(c0
);
3400 ast_channel_unlock(c1
);
3401 return AST_BRIDGE_FAILED_NOWARN
;
3403 /* They must also be using the same packetization */
3404 fmt0
= ast_codec_pref_getsize(&p0
->pref
, c0
->rawreadformat
);
3405 fmt1
= ast_codec_pref_getsize(&p1
->pref
, c1
->rawreadformat
);
3406 if (fmt0
.cur_ms
!= fmt1
.cur_ms
) {
3408 ast_log(LOG_DEBUG
, "Cannot packet2packet bridge - packetization settings prevent it\n");
3409 ast_channel_unlock(c0
);
3410 ast_channel_unlock(c1
);
3411 return AST_BRIDGE_FAILED_NOWARN
;
3414 if (option_verbose
> 2)
3415 ast_verbose(VERBOSE_PREFIX_3
"Packet2Packet bridging %s and %s\n", c0
->name
, c1
->name
);
3416 res
= bridge_p2p_loop(c0
, c1
, p0
, p1
, timeoutms
, flags
, fo
, rc
, pvt0
, pvt1
);
3418 if (option_verbose
> 2)
3419 ast_verbose(VERBOSE_PREFIX_3
"Native bridging %s and %s\n", c0
->name
, c1
->name
);
3420 res
= bridge_native_loop(c0
, c1
, p0
, p1
, vp0
, vp1
, pr0
, pr1
, codec0
, codec1
, timeoutms
, flags
, fo
, rc
, pvt0
, pvt1
);
3426 static int rtp_do_debug_ip(int fd
, int argc
, char *argv
[])
3429 struct ast_hostent ahp
;
3434 return RESULT_SHOWUSAGE
;
3436 p
= strstr(arg
, ":");
3442 hp
= ast_gethostbyname(arg
, &ahp
);
3444 return RESULT_SHOWUSAGE
;
3445 rtpdebugaddr
.sin_family
= AF_INET
;
3446 memcpy(&rtpdebugaddr
.sin_addr
, hp
->h_addr
, sizeof(rtpdebugaddr
.sin_addr
));
3447 rtpdebugaddr
.sin_port
= htons(port
);
3449 ast_cli(fd
, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtpdebugaddr
.sin_addr
));
3451 ast_cli(fd
, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtpdebugaddr
.sin_addr
), port
);
3453 return RESULT_SUCCESS
;
3456 static int rtcp_do_debug_ip_deprecated(int fd
, int argc
, char *argv
[])
3459 struct ast_hostent ahp
;
3463 return RESULT_SHOWUSAGE
;
3466 p
= strstr(arg
, ":");
3472 hp
= ast_gethostbyname(arg
, &ahp
);
3474 return RESULT_SHOWUSAGE
;
3475 rtcpdebugaddr
.sin_family
= AF_INET
;
3476 memcpy(&rtcpdebugaddr
.sin_addr
, hp
->h_addr
, sizeof(rtcpdebugaddr
.sin_addr
));
3477 rtcpdebugaddr
.sin_port
= htons(port
);
3479 ast_cli(fd
, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr
.sin_addr
));
3481 ast_cli(fd
, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr
.sin_addr
), port
);
3483 return RESULT_SUCCESS
;
3486 static int rtcp_do_debug_ip(int fd
, int argc
, char *argv
[])
3489 struct ast_hostent ahp
;
3493 return RESULT_SHOWUSAGE
;
3496 p
= strstr(arg
, ":");
3502 hp
= ast_gethostbyname(arg
, &ahp
);
3504 return RESULT_SHOWUSAGE
;
3505 rtcpdebugaddr
.sin_family
= AF_INET
;
3506 memcpy(&rtcpdebugaddr
.sin_addr
, hp
->h_addr
, sizeof(rtcpdebugaddr
.sin_addr
));
3507 rtcpdebugaddr
.sin_port
= htons(port
);
3509 ast_cli(fd
, "RTCP Debugging Enabled for IP: %s\n", ast_inet_ntoa(rtcpdebugaddr
.sin_addr
));
3511 ast_cli(fd
, "RTCP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(rtcpdebugaddr
.sin_addr
), port
);
3513 return RESULT_SUCCESS
;
3516 static int rtp_do_debug(int fd
, int argc
, char *argv
[])
3520 return RESULT_SHOWUSAGE
;
3521 return rtp_do_debug_ip(fd
, argc
, argv
);
3524 memset(&rtpdebugaddr
,0,sizeof(rtpdebugaddr
));
3525 ast_cli(fd
, "RTP Debugging Enabled\n");
3526 return RESULT_SUCCESS
;
3529 static int rtcp_do_debug_deprecated(int fd
, int argc
, char *argv
[]) {
3532 return RESULT_SHOWUSAGE
;
3533 return rtcp_do_debug_ip_deprecated(fd
, argc
, argv
);
3536 memset(&rtcpdebugaddr
,0,sizeof(rtcpdebugaddr
));
3537 ast_cli(fd
, "RTCP Debugging Enabled\n");
3538 return RESULT_SUCCESS
;
3541 static int rtcp_do_debug(int fd
, int argc
, char *argv
[]) {
3544 return RESULT_SHOWUSAGE
;
3545 return rtcp_do_debug_ip(fd
, argc
, argv
);
3548 memset(&rtcpdebugaddr
,0,sizeof(rtcpdebugaddr
));
3549 ast_cli(fd
, "RTCP Debugging Enabled\n");
3550 return RESULT_SUCCESS
;
3553 static int rtcp_do_stats_deprecated(int fd
, int argc
, char *argv
[]) {
3555 return RESULT_SHOWUSAGE
;
3558 ast_cli(fd
, "RTCP Stats Enabled\n");
3559 return RESULT_SUCCESS
;
3562 static int rtcp_do_stats(int fd
, int argc
, char *argv
[]) {
3564 return RESULT_SHOWUSAGE
;
3567 ast_cli(fd
, "RTCP Stats Enabled\n");
3568 return RESULT_SUCCESS
;
3571 static int rtp_no_debug(int fd
, int argc
, char *argv
[])
3574 return RESULT_SHOWUSAGE
;
3576 ast_cli(fd
,"RTP Debugging Disabled\n");
3577 return RESULT_SUCCESS
;
3580 static int rtcp_no_debug_deprecated(int fd
, int argc
, char *argv
[])
3583 return RESULT_SHOWUSAGE
;
3585 ast_cli(fd
,"RTCP Debugging Disabled\n");
3586 return RESULT_SUCCESS
;
3589 static int rtcp_no_debug(int fd
, int argc
, char *argv
[])
3592 return RESULT_SHOWUSAGE
;
3594 ast_cli(fd
,"RTCP Debugging Disabled\n");
3595 return RESULT_SUCCESS
;
3598 static int rtcp_no_stats_deprecated(int fd
, int argc
, char *argv
[])
3601 return RESULT_SHOWUSAGE
;
3603 ast_cli(fd
,"RTCP Stats Disabled\n");
3604 return RESULT_SUCCESS
;
3607 static int rtcp_no_stats(int fd
, int argc
, char *argv
[])
3610 return RESULT_SHOWUSAGE
;
3612 ast_cli(fd
,"RTCP Stats Disabled\n");
3613 return RESULT_SUCCESS
;
3616 static int stun_do_debug(int fd
, int argc
, char *argv
[])
3619 return RESULT_SHOWUSAGE
;
3622 ast_cli(fd
, "STUN Debugging Enabled\n");
3623 return RESULT_SUCCESS
;
3626 static int stun_no_debug(int fd
, int argc
, char *argv
[])
3629 return RESULT_SHOWUSAGE
;
3631 ast_cli(fd
, "STUN Debugging Disabled\n");
3632 return RESULT_SUCCESS
;
3635 static char debug_usage
[] =
3636 "Usage: rtp debug [ip host[:port]]\n"
3637 " Enable dumping of all RTP packets to and from host.\n";
3639 static char no_debug_usage
[] =
3640 "Usage: rtp debug off\n"
3641 " Disable all RTP debugging\n";
3643 static char stun_debug_usage
[] =
3644 "Usage: stun debug\n"
3645 " Enable STUN (Simple Traversal of UDP through NATs) debugging\n";
3647 static char stun_no_debug_usage
[] =
3648 "Usage: stun debug off\n"
3649 " Disable STUN debugging\n";
3651 static char rtcp_debug_usage
[] =
3652 "Usage: rtcp debug [ip host[:port]]\n"
3653 " Enable dumping of all RTCP packets to and from host.\n";
3655 static char rtcp_no_debug_usage
[] =
3656 "Usage: rtcp debug off\n"
3657 " Disable all RTCP debugging\n";
3659 static char rtcp_stats_usage
[] =
3660 "Usage: rtcp stats\n"
3661 " Enable dumping of RTCP stats.\n";
3663 static char rtcp_no_stats_usage
[] =
3664 "Usage: rtcp stats off\n"
3665 " Disable all RTCP stats\n";
3667 static struct ast_cli_entry cli_rtp_no_debug_deprecated
= {
3668 { "rtp", "no", "debug", NULL
},
3672 static struct ast_cli_entry cli_rtp_rtcp_debug_ip_deprecated
= {
3673 { "rtp", "rtcp", "debug", "ip", NULL
},
3674 rtcp_do_debug_deprecated
, NULL
,
3677 static struct ast_cli_entry cli_rtp_rtcp_debug_deprecated
= {
3678 { "rtp", "rtcp", "debug", NULL
},
3679 rtcp_do_debug_deprecated
, NULL
,
3682 static struct ast_cli_entry cli_rtp_rtcp_no_debug_deprecated
= {
3683 { "rtp", "rtcp", "no", "debug", NULL
},
3684 rtcp_no_debug_deprecated
, NULL
,
3687 static struct ast_cli_entry cli_rtp_rtcp_stats_deprecated
= {
3688 { "rtp", "rtcp", "stats", NULL
},
3689 rtcp_do_stats_deprecated
, NULL
,
3692 static struct ast_cli_entry cli_rtp_rtcp_no_stats_deprecated
= {
3693 { "rtp", "rtcp", "no", "stats", NULL
},
3694 rtcp_no_stats_deprecated
, NULL
,
3697 static struct ast_cli_entry cli_stun_no_debug_deprecated
= {
3698 { "stun", "no", "debug", NULL
},
3699 stun_no_debug
, NULL
,
3702 static struct ast_cli_entry cli_rtp
[] = {
3703 { { "rtp", "debug", "ip", NULL
},
3704 rtp_do_debug
, "Enable RTP debugging on IP",
3707 { { "rtp", "debug", NULL
},
3708 rtp_do_debug
, "Enable RTP debugging",
3711 { { "rtp", "debug", "off", NULL
},
3712 rtp_no_debug
, "Disable RTP debugging",
3713 no_debug_usage
, NULL
, &cli_rtp_no_debug_deprecated
},
3715 { { "rtcp", "debug", "ip", NULL
},
3716 rtcp_do_debug
, "Enable RTCP debugging on IP",
3717 rtcp_debug_usage
, NULL
, &cli_rtp_rtcp_debug_ip_deprecated
},
3719 { { "rtcp", "debug", NULL
},
3720 rtcp_do_debug
, "Enable RTCP debugging",
3721 rtcp_debug_usage
, NULL
, &cli_rtp_rtcp_debug_deprecated
},
3723 { { "rtcp", "debug", "off", NULL
},
3724 rtcp_no_debug
, "Disable RTCP debugging",
3725 rtcp_no_debug_usage
, NULL
, &cli_rtp_rtcp_no_debug_deprecated
},
3727 { { "rtcp", "stats", NULL
},
3728 rtcp_do_stats
, "Enable RTCP stats",
3729 rtcp_stats_usage
, NULL
, &cli_rtp_rtcp_stats_deprecated
},
3731 { { "rtcp", "stats", "off", NULL
},
3732 rtcp_no_stats
, "Disable RTCP stats",
3733 rtcp_no_stats_usage
, NULL
, &cli_rtp_rtcp_no_stats_deprecated
},
3735 { { "stun", "debug", NULL
},
3736 stun_do_debug
, "Enable STUN debugging",
3739 { { "stun", "debug", "off", NULL
},
3740 stun_no_debug
, "Disable STUN debugging",
3741 stun_no_debug_usage
, NULL
, &cli_stun_no_debug_deprecated
},
3744 int ast_rtp_reload(void)
3746 struct ast_config
*cfg
;
3751 dtmftimeout
= DEFAULT_DTMF_TIMEOUT
;
3752 cfg
= ast_config_load("rtp.conf");
3754 if ((s
= ast_variable_retrieve(cfg
, "general", "rtpstart"))) {
3756 if (rtpstart
< 1024)
3758 if (rtpstart
> 65535)
3761 if ((s
= ast_variable_retrieve(cfg
, "general", "rtpend"))) {
3768 if ((s
= ast_variable_retrieve(cfg
, "general", "rtcpinterval"))) {
3769 rtcpinterval
= atoi(s
);
3770 if (rtcpinterval
== 0)
3771 rtcpinterval
= 0; /* Just so we're clear... it's zero */
3772 if (rtcpinterval
< RTCP_MIN_INTERVALMS
)
3773 rtcpinterval
= RTCP_MIN_INTERVALMS
; /* This catches negative numbers too */
3774 if (rtcpinterval
> RTCP_MAX_INTERVALMS
)
3775 rtcpinterval
= RTCP_MAX_INTERVALMS
;
3777 if ((s
= ast_variable_retrieve(cfg
, "general", "rtpchecksums"))) {
3785 ast_log(LOG_WARNING
, "Disabling RTP checksums is not supported on this operating system!\n");
3788 if ((s
= ast_variable_retrieve(cfg
, "general", "dtmftimeout"))) {
3789 dtmftimeout
= atoi(s
);
3790 if ((dtmftimeout
< 0) || (dtmftimeout
> 20000)) {
3791 ast_log(LOG_WARNING
, "DTMF timeout of '%d' outside range, using default of '%d' instead\n",
3792 dtmftimeout
, DEFAULT_DTMF_TIMEOUT
);
3793 dtmftimeout
= DEFAULT_DTMF_TIMEOUT
;
3796 ast_config_destroy(cfg
);
3798 if (rtpstart
>= rtpend
) {
3799 ast_log(LOG_WARNING
, "Unreasonable values for RTP start/end port in rtp.conf\n");
3803 if (option_verbose
> 1)
3804 ast_verbose(VERBOSE_PREFIX_2
"RTP Allocating from port range %d -> %d\n", rtpstart
, rtpend
);
3808 /*! \brief Initialize the RTP system in Asterisk */
3809 void ast_rtp_init(void)
3811 ast_cli_register_multiple(cli_rtp
, sizeof(cli_rtp
) / sizeof(struct ast_cli_entry
));