Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:46 2007

Asterisk developer's documentation :: Codename Pineapple

---

rtp.c File Reference

---

Detailed Description

Supports RTP and RTCP with Symmetric RTP support for NAT traversal.

Author:

Mark Spencer <markster@digium.com>

Note:

RTP is defined in RFC 3550.

Definition in file rtp.c.

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include "asterisk/rtp.h"
#include "asterisk/frame.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/channel.h"
#include "asterisk/acl.h"
#include "asterisk/config.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/cli.h"
#include "asterisk/unaligned.h"

Include dependency graph for rtp.c:

Go to the source code of this file.

Data Structures
struct	__attribute__
struct	ast_rtcp
	Structure defining an RTCP session. More...
struct	ast_rtp
	RTP session description. More...
struct	rtpPayloadType
	Structure representing a RTP session.The value of each payload format mapping:. More...
struct	stun_addr
struct	stun_attr
struct	stun_header
struct	stun_state
Defines
#define	DEFAULT_DTMF_TIMEOUT   3000
#define	FLAG_3389_WARNING   (1 << 0)
#define	FLAG_CALLBACK_MODE   (1 << 6)
#define	FLAG_DTMF_COMPENSATE   (1 << 7)
#define	FLAG_HAS_DTMF   (1 << 3)
#define	FLAG_HAS_STUN   (1 << 8)
#define	FLAG_NAT_ACTIVE   (3 << 1)
#define	FLAG_NAT_INACTIVE   (0 << 1)
#define	FLAG_NAT_INACTIVE_NOWARN   (1 << 1)
#define	FLAG_P2P_NEED_DTMF   (1 << 5)
#define	FLAG_P2P_SENT_MARK   (1 << 4)
#define	MAX_TIMESTAMP_SKEW   640
#define	RTCP_DEFAULT_INTERVALMS   5000
#define	RTCP_MAX_INTERVALMS   60000
#define	RTCP_MIN_INTERVALMS   500
#define	RTCP_PT_APP   204
#define	RTCP_PT_BYE   203
#define	RTCP_PT_FUR   192
#define	RTCP_PT_RR   201
#define	RTCP_PT_SDES   202
#define	RTCP_PT_SR   200
#define	RTP_MTU   1200
#define	RTP_SEQ_MOD   (1<<16)
#define	STUN_ACCEPT   (1)
#define	STUN_BINDERR   0x0111
#define	STUN_BINDREQ   0x0001
#define	STUN_BINDRESP   0x0101
#define	STUN_CHANGE_REQUEST   0x0003
#define	STUN_CHANGED_ADDRESS   0x0005
#define	STUN_ERROR_CODE   0x0009
#define	STUN_IGNORE   (0)
#define	STUN_MAPPED_ADDRESS   0x0001
#define	STUN_MESSAGE_INTEGRITY   0x0008
#define	STUN_PASSWORD   0x0007
#define	STUN_REFLECTED_FROM   0x000b
#define	STUN_RESPONSE_ADDRESS   0x0002
#define	STUN_SECERR   0x0112
#define	STUN_SECREQ   0x0002
#define	STUN_SECRESP   0x0102
#define	STUN_SOURCE_ADDRESS   0x0004
#define	STUN_UNKNOWN_ATTRIBUTES   0x000a
#define	STUN_USERNAME   0x0006
Functions
static void	append_attr_address (struct stun_attr **attr, int attrval, struct sockaddr_in *sin, int *len, int *left)
static void	append_attr_string (struct stun_attr **attr, int attrval, const char *s, int *len, int *left)
static unsigned int	ast_rtcp_calc_interval (struct ast_rtp *rtp)
int	ast_rtcp_fd (struct ast_rtp *rtp)
static struct ast_rtcp *	ast_rtcp_new (void)
	Initialize a new RTCP session.
ast_frame *	ast_rtcp_read (struct ast_rtp *rtp)
int	ast_rtcp_send_h261fur (void *data)
	Send an H.261 fast update request. Some devices need this rather than the XML message in SIP.
static int	ast_rtcp_write (void *data)
	Write and RTCP packet to the far end.
static int	ast_rtcp_write_rr (void *data)
	Send RTCP recipient's report.
static int	ast_rtcp_write_sr (void *data)
	Send RTCP sender's report.
size_t	ast_rtp_alloc_size (void)
	Get the amount of space required to hold an RTP session.
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)
	The RTP bridge.
int	ast_rtp_codec_getformat (int pt)
ast_codec_pref *	ast_rtp_codec_getpref (struct ast_rtp *rtp)
int	ast_rtp_codec_setpref (struct ast_rtp *rtp, struct ast_codec_pref *prefs)
void	ast_rtp_destroy (struct ast_rtp *rtp)
int	ast_rtp_early_bridge (struct ast_channel *c0, struct ast_channel *c1)
	If possible, create an early bridge directly between the devices without having to send a re-invite later.
int	ast_rtp_fd (struct ast_rtp *rtp)
ast_rtp *	ast_rtp_get_bridged (struct ast_rtp *rtp)
void	ast_rtp_get_current_formats (struct ast_rtp *rtp, int *astFormats, int *nonAstFormats)
	Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs.
int	ast_rtp_get_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
char *	ast_rtp_get_quality (struct ast_rtp *rtp)
int	ast_rtp_get_rtpholdtimeout (struct ast_rtp *rtp)
	Get rtp hold timeout.
int	ast_rtp_get_rtpkeepalive (struct ast_rtp *rtp)
	Get RTP keepalive interval.
int	ast_rtp_get_rtptimeout (struct ast_rtp *rtp)
	Get rtp timeout.
void	ast_rtp_get_us (struct ast_rtp *rtp, struct sockaddr_in *us)
int	ast_rtp_getnat (struct ast_rtp *rtp)
void	ast_rtp_init (void)
	Return RTCP quality string.
int	ast_rtp_lookup_code (struct ast_rtp *rtp, const int isAstFormat, const int code)
	Looks up an RTP code out of our *static* outbound list.
char *	ast_rtp_lookup_mime_multiple (char *buf, size_t size, const int capability, const int isAstFormat, enum ast_rtp_options options)
	Build a string of MIME subtype names from a capability list.
const char *	ast_rtp_lookup_mime_subtype (const int isAstFormat, const int code, enum ast_rtp_options options)
	Mapping an Asterisk code into a MIME subtype (string):.
rtpPayloadType	ast_rtp_lookup_pt (struct ast_rtp *rtp, int pt)
	Mapping between RTP payload format codes and Asterisk codes:.
int	ast_rtp_make_compatible (struct ast_channel *dest, struct ast_channel *src, int media)
ast_rtp *	ast_rtp_new (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
	Initializate a RTP session.
void	ast_rtp_new_init (struct ast_rtp *rtp)
	Initialize a new RTP structure.
ast_rtp *	ast_rtp_new_with_bindaddr (struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
	Initializate a RTP session using an in_addr structure.
int	ast_rtp_proto_register (struct ast_rtp_protocol *proto)
	Register an RTP channel client.
void	ast_rtp_proto_unregister (struct ast_rtp_protocol *proto)
	Unregister an RTP channel client.
void	ast_rtp_pt_clear (struct ast_rtp *rtp)
	Setting RTP payload types from lines in a SDP description:.
void	ast_rtp_pt_copy (struct ast_rtp *dest, struct ast_rtp *src)
	Copy payload types between RTP structures.
void	ast_rtp_pt_default (struct ast_rtp *rtp)
	Set payload types to defaults.
static int	ast_rtp_raw_write (struct ast_rtp *rtp, struct ast_frame *f, int codec)
	Write RTP packet with audio or video media frames into UDP packet.
ast_frame *	ast_rtp_read (struct ast_rtp *rtp)
int	ast_rtp_reload (void)
void	ast_rtp_reset (struct ast_rtp *rtp)
int	ast_rtp_sendcng (struct ast_rtp *rtp, int level)
	generate comfort noice (CNG)
int	ast_rtp_senddigit_begin (struct ast_rtp *rtp, char digit)
	Send begin frames for DTMF.
static int	ast_rtp_senddigit_continuation (struct ast_rtp *rtp)
	Send continuation frame for DTMF.
int	ast_rtp_senddigit_end (struct ast_rtp *rtp, char digit)
	Send end packets for DTMF.
void	ast_rtp_set_callback (struct ast_rtp *rtp, ast_rtp_callback callback)
void	ast_rtp_set_data (struct ast_rtp *rtp, void *data)
void	ast_rtp_set_m_type (struct ast_rtp *rtp, int pt)
	Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line).
void	ast_rtp_set_peer (struct ast_rtp *rtp, struct sockaddr_in *them)
void	ast_rtp_set_rtpholdtimeout (struct ast_rtp *rtp, int timeout)
	Set rtp hold timeout.
void	ast_rtp_set_rtpkeepalive (struct ast_rtp *rtp, int period)
	set RTP keepalive interval
void	ast_rtp_set_rtpmap_type (struct ast_rtp *rtp, int pt, char *mimeType, char *mimeSubtype, enum ast_rtp_options options)
	Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line.
void	ast_rtp_set_rtptimeout (struct ast_rtp *rtp, int timeout)
	Set rtp timeout.
void	ast_rtp_set_rtptimers_onhold (struct ast_rtp *rtp)
void	ast_rtp_setdtmf (struct ast_rtp *rtp, int dtmf)
	Indicate whether this RTP session is carrying DTMF or not.
void	ast_rtp_setdtmfcompensate (struct ast_rtp *rtp, int compensate)
	Compensate for devices that send RFC2833 packets all at once.
void	ast_rtp_setnat (struct ast_rtp *rtp, int nat)
void	ast_rtp_setstun (struct ast_rtp *rtp, int stun_enable)
	Enable STUN capability.
int	ast_rtp_settos (struct ast_rtp *rtp, int tos)
void	ast_rtp_stop (struct ast_rtp *rtp)
void	ast_rtp_stun_request (struct ast_rtp *rtp, struct sockaddr_in *suggestion, const char *username)
	Send STUN request (??).
int	ast_rtp_write (struct ast_rtp *rtp, struct ast_frame *_f)
static	AST_RWLIST_HEAD_STATIC (protos, ast_rtp_protocol)
	List of current sessions.
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)
	Bridge loop for true native bridge (reinvite).
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)
	Bridge loop for partial native bridge (packet2packet).
static int	bridge_p2p_rtp_write (struct ast_rtp *rtp, struct ast_rtp *bridged, unsigned int *rtpheader, int len, int hdrlen)
	Perform a Packet2Packet RTP write.
static void	calc_rxstamp (struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
static unsigned int	calc_txstamp (struct ast_rtp *rtp, struct timeval *delivery)
static struct ast_rtp_protocol *	get_proto (struct ast_channel *chan)
	Get channel driver interface structure.
static int	p2p_callback_disable (struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
	Helper function to switch a channel and RTP stream out of callback mode.
static int	p2p_callback_enable (struct ast_channel *chan, struct ast_rtp *rtp, int **iod)
	P2P RTP Callback.
static void	p2p_set_bridge (struct ast_rtp *rtp0, struct ast_rtp *rtp1)
	Helper function that sets what an RTP structure is bridged to.
static struct ast_frame *	process_cisco_dtmf (struct ast_rtp *rtp, unsigned char *data, int len)
static struct ast_frame *	process_rfc2833 (struct ast_rtp *rtp, unsigned char *data, int len, unsigned int seqno)
	Process RTP DTMF and events according to RFC 2833.
static struct ast_frame *	process_rfc3389 (struct ast_rtp *rtp, unsigned char *data, int len)
	Process Comfort Noise RTP.
static int	rtcp_debug_test_addr (struct sockaddr_in *addr)
static int	rtcp_do_debug (int fd, int argc, char *argv[])
static int	rtcp_do_debug_ip (int fd, int argc, char *argv[])
static int	rtcp_do_stats (int fd, int argc, char *argv[])
static int	rtcp_no_debug (int fd, int argc, char *argv[])
static int	rtcp_no_stats (int fd, int argc, char *argv[])
static void	rtp_bridge_lock (struct ast_rtp *rtp)
static void	rtp_bridge_unlock (struct ast_rtp *rtp)
static int	rtp_debug_test_addr (struct sockaddr_in *addr)
static int	rtp_do_debug (int fd, int argc, char *argv[])
static int	rtp_do_debug_ip (int fd, int argc, char *argv[])
static int	rtp_no_debug (int fd, int argc, char *argv[])
static int	rtp_socket (void)
	Open RTP or RTCP socket for a session.
static int	rtpread (int *id, int fd, short events, void *cbdata)
static struct ast_frame *	send_dtmf (struct ast_rtp *rtp, enum ast_frame_type type)
static const char *	stun_attr2str (int msg)
static int	stun_do_debug (int fd, int argc, char *argv[])
static int	stun_handle_packet (int s, struct sockaddr_in *src, unsigned char *data, size_t len)
static const char *	stun_msg2str (int msg)
static int	stun_no_debug (int fd, int argc, char *argv[])
static int	stun_process_attr (struct stun_state *state, struct stun_attr *attr)
static void	stun_req_id (struct stun_header *req)
static int	stun_send (int s, struct sockaddr_in *dst, struct stun_header *resp)
static void	timeval2ntp (struct timeval tv, unsigned int *msw, unsigned int *lsw)
Variables
static struct ast_cli_entry	cli_rtp []
static const char	debug_usage []
static int	dtmftimeout = DEFAULT_DTMF_TIMEOUT
struct {
int   alarm
const char *   description
unsigned int   event_log:1
char *   ext
char *   mtype
char *   name
const char *   name
rtpPayloadType   payloadType
unsigned int   queue_log:1
char *   subtype
char *   type
int   val
}	mimeTypes []
static const char	no_debug_usage []
stun_addr	packed
stun_attr	packed
stun_header	packed
static const char	rtcp_debug_usage []
static const char	rtcp_no_debug_usage []
static const char	rtcp_no_stats_usage []
static const char	rtcp_stats_usage []
static int	rtcpdebug
static struct sockaddr_in	rtcpdebugaddr
static int	rtcpinterval = RTCP_DEFAULT_INTERVALMS
static int	rtcpstats
static int	rtpdebug
static struct sockaddr_in	rtpdebugaddr
static int	rtpend
static int	rtpstart
static struct rtpPayloadType	static_RTP_PT [MAX_RTP_PT]
static const char	stun_debug_usage []
static const char	stun_no_debug_usage []
static int	stundebug

---

Define Documentation

#define DEFAULT_DTMF_TIMEOUT   3000

samples Definition at line 76 of file rtp.c. Referenced by ast_rtp_reload().

#define FLAG_3389_WARNING   (1 << 0)

Definition at line 188 of file rtp.c. Referenced by process_rfc3389().

#define FLAG_CALLBACK_MODE   (1 << 6)

Definition at line 195 of file rtp.c. Referenced by p2p_callback_disable().

#define FLAG_DTMF_COMPENSATE   (1 << 7)

Definition at line 196 of file rtp.c. Referenced by ast_rtp_setdtmfcompensate(), process_cisco_dtmf(), process_rfc2833(), and send_dtmf().

#define FLAG_HAS_DTMF   (1 << 3)

Definition at line 192 of file rtp.c. Referenced by ast_rtp_bridge(), ast_rtp_new_init(), and ast_rtp_setdtmf().

#define FLAG_HAS_STUN   (1 << 8)

Definition at line 197 of file rtp.c. Referenced by ast_rtp_setstun().

#define FLAG_NAT_ACTIVE   (3 << 1)

Definition at line 189 of file rtp.c. Referenced by ast_rtp_early_bridge(), ast_rtp_getnat(), ast_rtp_make_compatible(), ast_rtp_raw_write(), ast_rtp_read(), bridge_native_loop(), and bridge_p2p_rtp_write().

#define FLAG_NAT_INACTIVE   (0 << 1)

Definition at line 190 of file rtp.c. Referenced by ast_rtp_raw_write(), and bridge_p2p_rtp_write().

#define FLAG_NAT_INACTIVE_NOWARN   (1 << 1)

Definition at line 191 of file rtp.c. Referenced by ast_rtp_raw_write(), and bridge_p2p_rtp_write().

#define FLAG_P2P_NEED_DTMF   (1 << 5)

Definition at line 194 of file rtp.c. Referenced by ast_rtp_bridge(), and bridge_p2p_rtp_write().

#define FLAG_P2P_SENT_MARK   (1 << 4)

Definition at line 193 of file rtp.c. Referenced by ast_rtp_stop(), bridge_p2p_loop(), and bridge_p2p_rtp_write().

#define MAX_TIMESTAMP_SKEW   640

Definition at line 60 of file rtp.c. Referenced by ast_rtp_raw_write(), calc_timestamp(), and calc_txpeerstamp().

#define RTCP_DEFAULT_INTERVALMS   5000

Default milli-seconds between RTCP reports we send Definition at line 63 of file rtp.c.

#define RTCP_MAX_INTERVALMS   60000

Max milli-seconds between RTCP reports we send Definition at line 65 of file rtp.c. Referenced by ast_rtp_reload().

#define RTCP_MIN_INTERVALMS   500

Min milli-seconds between RTCP reports we send Definition at line 64 of file rtp.c. Referenced by ast_rtp_reload().

#define RTCP_PT_APP   204

Definition at line 72 of file rtp.c.

#define RTCP_PT_BYE   203

Definition at line 71 of file rtp.c. Referenced by ast_rtcp_read().

#define RTCP_PT_FUR   192

Definition at line 67 of file rtp.c. Referenced by ast_rtcp_read(), ast_rtcp_write_rr(), and ast_rtcp_write_sr().

#define RTCP_PT_RR   201

Definition at line 69 of file rtp.c. Referenced by ast_rtcp_read(), and ast_rtcp_write_rr().

#define RTCP_PT_SDES   202

Definition at line 70 of file rtp.c. Referenced by ast_rtcp_read(), ast_rtcp_write_rr(), and ast_rtcp_write_sr().

#define RTCP_PT_SR   200

Definition at line 68 of file rtp.c. Referenced by ast_rtcp_read(), and ast_rtcp_write_sr().

#define RTP_MTU   1200

Definition at line 74 of file rtp.c.

#define RTP_SEQ_MOD   (1<<16)

A sequence number can't be more than 16 bits Definition at line 62 of file rtp.c. Referenced by ast_rtp_read().

#define STUN_ACCEPT   (1)

Definition at line 261 of file rtp.c. Referenced by ast_rtp_read(), and stun_handle_packet().

#define STUN_BINDERR   0x0111

Definition at line 265 of file rtp.c. Referenced by stun_msg2str().

#define STUN_BINDREQ   0x0001

Definition at line 263 of file rtp.c. Referenced by ast_rtp_stun_request(), stun_handle_packet(), and stun_msg2str().

#define STUN_BINDRESP   0x0101

Definition at line 264 of file rtp.c. Referenced by stun_handle_packet(), and stun_msg2str().

#define STUN_CHANGE_REQUEST   0x0003

Definition at line 272 of file rtp.c. Referenced by stun_attr2str().

#define STUN_CHANGED_ADDRESS   0x0005

Definition at line 274 of file rtp.c. Referenced by stun_attr2str().

#define STUN_ERROR_CODE   0x0009

Definition at line 278 of file rtp.c. Referenced by stun_attr2str().

#define STUN_IGNORE   (0)

Definition at line 260 of file rtp.c. Referenced by stun_handle_packet().

#define STUN_MAPPED_ADDRESS   0x0001

Definition at line 270 of file rtp.c. Referenced by stun_attr2str(), and stun_handle_packet().

#define STUN_MESSAGE_INTEGRITY   0x0008

Definition at line 277 of file rtp.c. Referenced by stun_attr2str().

#define STUN_PASSWORD   0x0007

Definition at line 276 of file rtp.c. Referenced by stun_attr2str(), and stun_process_attr().

#define STUN_REFLECTED_FROM   0x000b

Definition at line 280 of file rtp.c. Referenced by stun_attr2str().

#define STUN_RESPONSE_ADDRESS   0x0002

Definition at line 271 of file rtp.c. Referenced by stun_attr2str().

#define STUN_SECERR   0x0112

Definition at line 268 of file rtp.c. Referenced by stun_msg2str().

#define STUN_SECREQ   0x0002

Definition at line 266 of file rtp.c. Referenced by stun_msg2str().

#define STUN_SECRESP   0x0102

Definition at line 267 of file rtp.c. Referenced by stun_msg2str().

#define STUN_SOURCE_ADDRESS   0x0004

Definition at line 273 of file rtp.c. Referenced by stun_attr2str().

#define STUN_UNKNOWN_ATTRIBUTES   0x000a

Definition at line 279 of file rtp.c. Referenced by stun_attr2str().

#define STUN_USERNAME   0x0006

Definition at line 275 of file rtp.c. Referenced by ast_rtp_stun_request(), stun_attr2str(), stun_handle_packet(), and stun_process_attr().

---

Function Documentation

static void append_attr_address (  struct stun_attr **  attr, int  attrval, struct sockaddr_in *  sin, int *  len, int *  left )  [static]

Definition at line 368 of file rtp.c. References stun_addr::addr. Referenced by stun_handle_packet(). { int size = sizeof(**attr) + 8; struct stun_addr *addr; if (*left > size) { (*attr)->attr = htons(attrval); (*attr)->len = htons(8); addr = (struct stun_addr *)((*attr)->value); addr->unused = 0; addr->family = 0x01; addr->port = sin->sin_port; addr->addr = sin->sin_addr.s_addr; (*attr) = (struct stun_attr *)((*attr)->value + 8); *len += size; *left -= size; } }

static void append_attr_string (  struct stun_attr **  attr, int  attrval, const char *  s, int *  len, int *  left )  [static]

Definition at line 355 of file rtp.c. Referenced by ast_rtp_stun_request(), and stun_handle_packet(). { int size = sizeof(**attr) + strlen(s); if (*left > size) { (*attr)->attr = htons(attrval); (*attr)->len = htons(strlen(s)); memcpy((*attr)->value, s, strlen(s)); (*attr) = (struct stun_attr *)((*attr)->value + strlen(s)); *len += size; *left -= size; } }

unsigned int ast_rtcp_calc_interval (  struct ast_rtp *  rtp  )  [static]

Todo: XXX Do a more reasonable calculation on this one Look in RFC 3550 Section A.7 for an example Definition at line 526 of file rtp.c. Referenced by ast_rtp_raw_write(), and ast_rtp_read(). { unsigned int interval; /*! \todo XXX Do a more reasonable calculation on this one * Look in RFC 3550 Section A.7 for an example*/ interval = rtcpinterval; return interval; }

int ast_rtcp_fd (  struct ast_rtp *  rtp  )

Definition at line 519 of file rtp.c. References ast_rtp::rtcp, and ast_rtcp::s. Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), jingle_new(), sip_new(), and start_rtp(). { if (rtp->rtcp) return rtp->rtcp->s; return -1; }

static struct ast_rtcp* ast_rtcp_new (  void   )  [static]

Initialize a new RTCP session. Returns: The newly initialized RTCP session. Definition at line 1873 of file rtp.c. References ast_calloc, ast_log(), free, LOG_WARNING, rtp_socket(), and ast_rtcp::s. Referenced by ast_rtp_new_with_bindaddr(). { struct ast_rtcp *rtcp; if (!(rtcp = ast_calloc(1, sizeof(*rtcp)))) return NULL; rtcp->s = rtp_socket(); rtcp->us.sin_family = AF_INET; rtcp->them.sin_family = AF_INET; if (rtcp->s < 0) { free(rtcp); ast_log(LOG_WARNING, "Unable to allocate RTCP socket: %s\n", strerror(errno)); return NULL; } return rtcp; }

struct ast_frame* ast_rtcp_read (  struct ast_rtp *  rtp  )

Definition at line 888 of file rtp.c. References ast_rtcp::accumulated_transit, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_verbose(), CRASH, ast_frame::datalen, ast_rtp::f, ast_frame::frametype, len, LOG_DEBUG, LOG_WARNING, ast_frame::mallocd, ast_rtcp::maxrtt, ast_rtcp::minrtt, ast_rtp::nat, option_debug, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, rtcp_debug_test_addr(), RTCP_PT_BYE, RTCP_PT_FUR, RTCP_PT_RR, RTCP_PT_SDES, RTCP_PT_SR, ast_rtcp::rtt, ast_rtcp::rxlsr, ast_rtcp::s, ast_frame::samples, ast_rtcp::soc, ast_rtcp::spc, ast_frame::src, ast_frame::subclass, ast_rtcp::them, ast_rtcp::themrxlsr, and timeval2ntp(). Referenced by oh323_read(), sip_rtp_read(), and skinny_rtp_read(). { socklen_t len; int position, i, packetwords; int res; struct sockaddr_in sin; unsigned int rtcpdata[8192 + AST_FRIENDLY_OFFSET]; unsigned int *rtcpheader; int pt; struct timeval now; unsigned int length; int rc; double rtt = 0; double a; double dlsr; double lsr; unsigned int msw; unsigned int lsw; unsigned int comp; struct ast_frame *f = &ast_null_frame; if (!rtp || !rtp->rtcp) return &ast_null_frame; len = sizeof(sin); res = recvfrom(rtp->rtcp->s, rtcpdata + AST_FRIENDLY_OFFSET, sizeof(rtcpdata) - sizeof(unsigned int) * AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len); rtcpheader = (unsigned int *)(rtcpdata + AST_FRIENDLY_OFFSET); if (res < 0) { if (errno != EAGAIN) ast_log(LOG_WARNING, "RTCP Read error: %s\n", strerror(errno)); if (errno == EBADF) CRASH; return &ast_null_frame; } packetwords = res / 4; if (rtp->nat) { /* Send to whoever sent to us */ if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->rtcp->them.sin_port != sin.sin_port)) { memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); if (option_debug || rtpdebug) 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)); } } if (option_debug) ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res); /* Process a compound packet */ position = 0; while (position < packetwords) { i = position; length = ntohl(rtcpheader[i]); pt = (length & 0xff0000) >> 16; rc = (length & 0x1f000000) >> 24; length &= 0xffff; if ((i + length) > packetwords) { ast_log(LOG_WARNING, "RTCP Read too short\n"); return &ast_null_frame; } if (rtcp_debug_test_addr(&sin)) { ast_verbose("\n\nGot RTCP from %s:%d\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)); ast_verbose("PT: %d(%s)\n", pt, (pt == 200) ? "Sender Report" : (pt == 201) ? "Receiver Report" : (pt == 192) ? "H.261 FUR" : "Unknown"); ast_verbose("Reception reports: %d\n", rc); ast_verbose("SSRC of sender: %u\n", rtcpheader[i + 1]); } i += 2; /* Advance past header and ssrc */ switch (pt) { case RTCP_PT_SR: gettimeofday(&rtp->rtcp->rxlsr,NULL); /* To be able to populate the dlsr */ rtp->rtcp->spc = ntohl(rtcpheader[i+3]); rtp->rtcp->soc = ntohl(rtcpheader[i + 4]); rtp->rtcp->themrxlsr = ((ntohl(rtcpheader[i]) & 0x0000ffff) << 16) | ((ntohl(rtcpheader[i + 1]) & 0xffff) >> 16); /* Going to LSR in RR*/ if (rtcp_debug_test_addr(&sin)) { ast_verbose("NTP timestamp: %lu.%010lu\n", (unsigned long) ntohl(rtcpheader[i]), (unsigned long) ntohl(rtcpheader[i + 1]) * 4096); ast_verbose("RTP timestamp: %lu\n", (unsigned long) ntohl(rtcpheader[i + 2])); ast_verbose("SPC: %lu\tSOC: %lu\n", (unsigned long) ntohl(rtcpheader[i + 3]), (unsigned long) ntohl(rtcpheader[i + 4])); } i += 5; if (rc < 1) break; /* Intentional fall through */ case RTCP_PT_RR: /* This is the place to calculate RTT */ /* Don't handle multiple reception reports (rc > 1) yet */ gettimeofday(&now, NULL); timeval2ntp(now, &msw, &lsw); /* Use the one we sent them in our SR instead, rtcp->txlsr could have been rewritten if the dlsr is large */ if (ntohl(rtcpheader[i + 4])) { /* We must have the LSR */ comp = ((msw & 0xffff) << 16) | ((lsw & 0xffff0000) >> 16); a = (double)((comp & 0xffff0000) >> 16) + (double)((double)(comp & 0xffff)/1000000.); lsr = (double)((ntohl(rtcpheader[i + 4]) & 0xffff0000) >> 16) + (double)((double)(ntohl(rtcpheader[i + 4]) & 0xffff) / 1000000.); dlsr = (double)(ntohl(rtcpheader[i + 5])/65536.); rtt = a - dlsr - lsr; rtp->rtcp->accumulated_transit += rtt; rtp->rtcp->rtt = rtt; if (rtp->rtcp->maxrtt<rtt) rtp->rtcp->maxrtt = rtt; if (rtp->rtcp->minrtt>rtt) rtp->rtcp->minrtt = rtt; } rtp->rtcp->reported_jitter = ntohl(rtcpheader[i + 3]); rtp->rtcp->reported_lost = ntohl(rtcpheader[i + 1]) & 0xffffff; if (rtcp_debug_test_addr(&sin)) { ast_verbose("Fraction lost: %ld\n", (((long) ntohl(rtcpheader[i + 1]) & 0xff000000) >> 24)); ast_verbose("Packets lost so far: %d\n", rtp->rtcp->reported_lost); ast_verbose("Highest sequence number: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff)); ast_verbose("Sequence number cycles: %ld\n", (long) (ntohl(rtcpheader[i + 2]) & 0xffff) >> 16); ast_verbose("Interarrival jitter: %u\n", rtp->rtcp->reported_jitter); ast_verbose("Last SR(our NTP): %lu.%010lu\n",(unsigned long) ntohl(rtcpheader[i + 4]) >> 16,((unsigned long) ntohl(rtcpheader[i + 4]) << 16) * 4096); ast_verbose("DLSR: %4.4f (sec)\n",ntohl(rtcpheader[i + 5])/65536.0); if (rtt) ast_verbose("RTT: %f(sec)\n", rtt); } break; case RTCP_PT_FUR: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received an RTCP Fast Update Request\n"); rtp->f.frametype = AST_FRAME_CONTROL; rtp->f.subclass = AST_CONTROL_VIDUPDATE; rtp->f.datalen = 0; rtp->f.samples = 0; rtp->f.mallocd = 0; rtp->f.src = "RTP"; f = &rtp->f; break; case RTCP_PT_SDES: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received an SDES from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); break; case RTCP_PT_BYE: if (rtcp_debug_test_addr(&sin)) ast_verbose("Received a BYE from %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); break; default: if (option_debug) 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)); break; } position += (length + 1); } return f; }

int ast_rtcp_send_h261fur (  void *  data  )

Send an H.261 fast update request. Some devices need this rather than the XML message in SIP. Definition at line 2329 of file rtp.c. References ast_rtcp_write(), ast_rtp::rtcp, and ast_rtcp::sendfur. { struct ast_rtp *rtp = data; int res; rtp->rtcp->sendfur = 1; res = ast_rtcp_write(data); return res; }

static int ast_rtcp_write (  void *  data  )  [static]

Write and RTCP packet to the far end. Note: Decide if we are going to send an SR (with Reception Block) or RR RR is sent if we have not sent any rtp packets in the previous interval Definition at line 2554 of file rtp.c. References ast_rtcp_write_rr(), ast_rtcp_write_sr(), ast_rtcp::lastsrtxcount, ast_rtp::rtcp, and ast_rtp::txcount. Referenced by ast_rtcp_send_h261fur(), ast_rtp_raw_write(), and ast_rtp_read(). { struct ast_rtp *rtp = data; int res; if (rtp->txcount > rtp->rtcp->lastsrtxcount) res = ast_rtcp_write_sr(data); else res = ast_rtcp_write_rr(data); return res; }

static int ast_rtcp_write_rr (  void *  data  )  [static]

Send RTCP recipient's report. Note: Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos it can change mid call, and SDES can't) Definition at line 2455 of file rtp.c. References ast_inet_ntoa(), ast_log(), ast_sched_del(), ast_verbose(), ast_rtp::cycles, ast_rtcp::expected_prior, ast_rtp::lastrxseqno, len, LOG_ERROR, ast_rtcp::received_prior, ast_rtcp::rr_count, ast_rtp::rtcp, rtcp_debug_test_addr(), RTCP_PT_FUR, RTCP_PT_RR, RTCP_PT_SDES, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtcp::rxlsr, ast_rtcp::s, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seedrxseqno, ast_rtcp::sendfur, ast_rtp::ssrc, ast_rtcp::them, ast_rtcp::themrxlsr, and ast_rtp::themssrc. Referenced by ast_rtcp_write(). { struct ast_rtp *rtp = data; int res; int len = 32; unsigned int lost; unsigned int extended; unsigned int expected; unsigned int expected_interval; unsigned int received_interval; int lost_interval; struct timeval now; unsigned int *rtcpheader; char bdata[1024]; struct timeval dlsr; int fraction; if (!rtp || !rtp->rtcp || (&rtp->rtcp->them.sin_addr == 0)) return 0; if (!rtp->rtcp->them.sin_addr.s_addr) { ast_log(LOG_ERROR, "RTCP RR transmission error to, rtcp halted %s\n",strerror(errno)); if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; return 0; } extended = rtp->cycles + rtp->lastrxseqno; expected = extended - rtp->seedrxseqno + 1; lost = expected - rtp->rxcount; expected_interval = expected - rtp->rtcp->expected_prior; rtp->rtcp->expected_prior = expected; received_interval = rtp->rxcount - rtp->rtcp->received_prior; rtp->rtcp->received_prior = rtp->rxcount; lost_interval = expected_interval - received_interval; if (expected_interval == 0 || lost_interval <= 0) fraction = 0; else fraction = (lost_interval << 8) / expected_interval; gettimeofday(&now, NULL); timersub(&now, &rtp->rtcp->rxlsr, &dlsr); rtcpheader = (unsigned int *)bdata; rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_RR << 16) | ((len/4)-1)); rtcpheader[1] = htonl(rtp->ssrc); rtcpheader[2] = htonl(rtp->themssrc); rtcpheader[3] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff)); rtcpheader[4] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff))); rtcpheader[5] = htonl((unsigned int)rtp->rxjitter); rtcpheader[6] = htonl(rtp->rtcp->themrxlsr); rtcpheader[7] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000); if (rtp->rtcp->sendfur) { rtcpheader[8] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); /* Header from page 36 in RFC 3550 */ rtcpheader[9] = htonl(rtp->ssrc); /* Our SSRC */ len += 8; rtp->rtcp->sendfur = 0; } /*! \note Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos it can change mid call, and SDES can't) */ rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2); rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */ rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */ len += 12; res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them)); if (res < 0) { ast_log(LOG_ERROR, "RTCP RR transmission error, rtcp halted: %s\n",strerror(errno)); /* Remove the scheduler */ if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; return 0; } rtp->rtcp->rr_count++; if (rtcp_debug_test_addr(&rtp->rtcp->them)) { ast_verbose("\n* Sending RTCP RR to %s:%d\n" " Our SSRC: %u\nTheir SSRC: %u\niFraction lost: %d\nCumulative loss: %u\n" " IA jitter: %.4f\n" " Their last SR: %u\n" " DLSR: %4.4f (sec)\n\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port), rtp->ssrc, rtp->themssrc, fraction, lost, rtp->rxjitter, rtp->rtcp->themrxlsr, (double)(ntohl(rtcpheader[7])/65536.0)); } return res; }

static int ast_rtcp_write_sr (  void *  data  )  [static]

Send RTCP sender's report. Definition at line 2341 of file rtp.c. References ast_inet_ntoa(), ast_log(), ast_sched_del(), ast_verbose(), ast_rtp::cycles, ast_rtcp::expected_prior, ast_rtp::lastrxseqno, ast_rtcp::lastsrtxcount, ast_rtp::lastts, len, LOG_ERROR, ast_rtcp::received_prior, ast_rtp::rtcp, rtcp_debug_test_addr(), RTCP_PT_FUR, RTCP_PT_SDES, RTCP_PT_SR, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtcp::rxlsr, ast_rtcp::s, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seedrxseqno, ast_rtcp::sendfur, ast_rtcp::sr_count, ast_rtp::ssrc, ast_rtcp::them, ast_rtcp::themrxlsr, ast_rtp::themssrc, timeval2ntp(), ast_rtp::txcount, ast_rtcp::txlsr, and ast_rtp::txoctetcount. Referenced by ast_rtcp_write(). { struct ast_rtp *rtp = data; int res; int len = 0; struct timeval now; unsigned int now_lsw; unsigned int now_msw; unsigned int *rtcpheader; unsigned int lost; unsigned int extended; unsigned int expected; unsigned int expected_interval; unsigned int received_interval; int lost_interval; int fraction; struct timeval dlsr; char bdata[512]; /* Commented condition is always not NULL if rtp->rtcp is not NULL */ if (!rtp || !rtp->rtcp/* || (&rtp->rtcp->them.sin_addr == 0)*/) return 0; if (!rtp->rtcp->them.sin_addr.s_addr) { /* This'll stop rtcp for this rtp session */ ast_verbose("RTCP SR transmission error, rtcp halted\n"); if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; return 0; } gettimeofday(&now, NULL); timeval2ntp(now, &now_msw, &now_lsw); /* fill thses ones in from utils.c*/ rtcpheader = (unsigned int *)bdata; rtcpheader[1] = htonl(rtp->ssrc); /* Our SSRC */ rtcpheader[2] = htonl(now_msw); /* now, MSW. gettimeofday() + SEC_BETWEEN_1900_AND_1970*/ rtcpheader[3] = htonl(now_lsw); /* now, LSW */ rtcpheader[4] = htonl(rtp->lastts); /* FIXME shouldn't be that, it should be now */ rtcpheader[5] = htonl(rtp->txcount); /* No. packets sent */ rtcpheader[6] = htonl(rtp->txoctetcount); /* No. bytes sent */ len += 28; extended = rtp->cycles + rtp->lastrxseqno; expected = extended - rtp->seedrxseqno + 1; if (rtp->rxcount > expected) expected += rtp->rxcount - expected; lost = expected - rtp->rxcount; expected_interval = expected - rtp->rtcp->expected_prior; rtp->rtcp->expected_prior = expected; received_interval = rtp->rxcount - rtp->rtcp->received_prior; rtp->rtcp->received_prior = rtp->rxcount; lost_interval = expected_interval - received_interval; if (expected_interval == 0 || lost_interval <= 0) fraction = 0; else fraction = (lost_interval << 8) / expected_interval; timersub(&now, &rtp->rtcp->rxlsr, &dlsr); rtcpheader[7] = htonl(rtp->themssrc); rtcpheader[8] = htonl(((fraction & 0xff) << 24) | (lost & 0xffffff)); rtcpheader[9] = htonl((rtp->cycles) | ((rtp->lastrxseqno & 0xffff))); rtcpheader[10] = htonl((unsigned int)rtp->rxjitter); rtcpheader[11] = htonl(rtp->rtcp->themrxlsr); rtcpheader[12] = htonl((((dlsr.tv_sec * 1000) + (dlsr.tv_usec / 1000)) * 65536) / 1000); len += 24; rtcpheader[0] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SR << 16) | ((len/4)-1)); if (rtp->rtcp->sendfur) { rtcpheader[13] = htonl((2 << 30) | (0 << 24) | (RTCP_PT_FUR << 16) | 1); rtcpheader[14] = htonl(rtp->ssrc); /* Our SSRC */ len += 8; rtp->rtcp->sendfur = 0; } /* Insert SDES here. Probably should make SDES text equal to mimetypes[code].type (not subtype 'cos */ /* it can change mid call, and SDES can't) */ rtcpheader[len/4] = htonl((2 << 30) | (1 << 24) | (RTCP_PT_SDES << 16) | 2); rtcpheader[(len/4)+1] = htonl(rtp->ssrc); /* Our SSRC */ rtcpheader[(len/4)+2] = htonl(0x01 << 24); /* Empty for the moment */ len += 12; res = sendto(rtp->rtcp->s, (unsigned int *)rtcpheader, len, 0, (struct sockaddr *)&rtp->rtcp->them, sizeof(rtp->rtcp->them)); if (res < 0) { 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)); if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; return 0; } /* FIXME Don't need to get a new one */ gettimeofday(&rtp->rtcp->txlsr, NULL); rtp->rtcp->sr_count++; rtp->rtcp->lastsrtxcount = rtp->txcount; if (rtcp_debug_test_addr(&rtp->rtcp->them)) { ast_verbose("* Sent RTCP SR to %s:%d\n", ast_inet_ntoa(rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port)); ast_verbose(" Our SSRC: %u\n", rtp->ssrc); ast_verbose(" Sent(NTP): %u.%010u\n", (unsigned int)now.tv_sec, (unsigned int)now.tv_usec*4096); ast_verbose(" Sent(RTP): %u\n", rtp->lastts); ast_verbose(" Sent packets: %u\n", rtp->txcount); ast_verbose(" Sent octets: %u\n", rtp->txoctetcount); ast_verbose(" Report block:\n"); ast_verbose(" Fraction lost: %u\n", fraction); ast_verbose(" Cumulative loss: %u\n", lost); ast_verbose(" IA jitter: %.4f\n", rtp->rxjitter); ast_verbose(" Their last SR: %u\n", rtp->rtcp->themrxlsr); ast_verbose(" DLSR: %4.4f (sec)\n\n", (double)(ntohl(rtcpheader[12])/65536.0)); } return res; }

size_t ast_rtp_alloc_size (  void   )

Get the amount of space required to hold an RTP session. Returns: number of bytes required Definition at line 399 of file rtp.c. Referenced by process_sdp(). { return sizeof(struct ast_rtp); }

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 )

The RTP bridge. The Asterisk RTP bridge Definition at line 3259 of file rtp.c. References AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, AST_RTP_TRY_PARTIAL, ast_set_flag, ast_test_flag, ast_verbose(), bridge_native_loop(), bridge_p2p_loop(), FLAG_HAS_DTMF, FLAG_P2P_NEED_DTMF, ast_rtp_protocol::get_codec, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, option_debug, option_verbose, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel_tech::send_digit_begin, ast_channel::tech, ast_channel::tech_pvt, and VERBOSE_PREFIX_3. { struct ast_rtp *p0 = NULL, *p1 = NULL; /* Audio RTP Channels */ struct ast_rtp *vp0 = NULL, *vp1 = NULL; /* Video RTP channels */ struct ast_rtp_protocol *pr0 = NULL, *pr1 = NULL; enum ast_rtp_get_result audio_p0_res = AST_RTP_GET_FAILED, video_p0_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_p1_res = AST_RTP_GET_FAILED, video_p1_res = AST_RTP_GET_FAILED; enum ast_bridge_result res = AST_BRIDGE_FAILED; int codec0 = 0, codec1 = 0; void *pvt0 = NULL, *pvt1 = NULL; /* Lock channels */ ast_channel_lock(c0); while (ast_channel_trylock(c1)) { ast_channel_unlock(c0); usleep(1); ast_channel_lock(c0); } /* Find channel driver interfaces */ if (!(pr0 = get_proto(c0))) { ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED; } if (!(pr1 = get_proto(c1))) { ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED; } /* Get channel specific interface structures */ pvt0 = c0->tech_pvt; pvt1 = c1->tech_pvt; /* Get audio and video interface (if native bridge is possible) */ audio_p0_res = pr0->get_rtp_info(c0, &p0); video_p0_res = pr0->get_vrtp_info ? pr0->get_vrtp_info(c0, &vp0) : AST_RTP_GET_FAILED; audio_p1_res = pr1->get_rtp_info(c1, &p1); video_p1_res = pr1->get_vrtp_info ? pr1->get_vrtp_info(c1, &vp1) : AST_RTP_GET_FAILED; /* If we are carrying video, and both sides are not reinviting... then fail the native bridge */ if (video_p0_res != AST_RTP_GET_FAILED && (audio_p0_res != AST_RTP_TRY_NATIVE || video_p0_res != AST_RTP_TRY_NATIVE)) audio_p0_res = AST_RTP_GET_FAILED; if (video_p1_res != AST_RTP_GET_FAILED && (audio_p1_res != AST_RTP_TRY_NATIVE || video_p1_res != AST_RTP_TRY_NATIVE)) audio_p1_res = AST_RTP_GET_FAILED; /* Check if a bridge is possible (partial/native) */ if (audio_p0_res == AST_RTP_GET_FAILED || audio_p1_res == AST_RTP_GET_FAILED) { /* Somebody doesn't want to play... */ ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } /* If we need to feed DTMF frames into the core then only do a partial native bridge */ if (ast_test_flag(p0, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) { ast_set_flag(p0, FLAG_P2P_NEED_DTMF); audio_p0_res = AST_RTP_TRY_PARTIAL; } if (ast_test_flag(p1, FLAG_HAS_DTMF) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) { ast_set_flag(p1, FLAG_P2P_NEED_DTMF); audio_p1_res = AST_RTP_TRY_PARTIAL; } /* If both sides are not using the same method of DTMF transmission * (ie: one is RFC2833, other is INFO... then we can not do direct media. * -------------------------------------------------- * | DTMF Mode | HAS_DTMF | Accepts Begin Frames | * |-----------|------------|-----------------------| * | Inband | False | True | * | RFC2833 | True | True | * | SIP INFO | False | False | * -------------------------------------------------- * However, if DTMF from both channels is being monitored by the core, then * we can still do packet-to-packet bridging, because passing through the * core will handle DTMF mode translation. */ if ( (ast_test_flag(p0, FLAG_HAS_DTMF) != ast_test_flag(p1, FLAG_HAS_DTMF)) || (!c0->tech->send_digit_begin != !c1->tech->send_digit_begin)) { if (!ast_test_flag(p0, FLAG_P2P_NEED_DTMF) || !ast_test_flag(p1, FLAG_P2P_NEED_DTMF)) { ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } audio_p0_res = AST_RTP_TRY_PARTIAL; audio_p1_res = AST_RTP_TRY_PARTIAL; } /* Get codecs from both sides */ codec0 = pr0->get_codec ? pr0->get_codec(c0) : 0; codec1 = pr1->get_codec ? pr1->get_codec(c1) : 0; if (codec0 && codec1 && !(codec0 & codec1)) { /* Hey, we can't do native bridging if both parties speak different codecs */ if (option_debug > 2) ast_log(LOG_DEBUG, "Channel codec0 = %d is not codec1 = %d, cannot native bridge in RTP.\n", codec0, codec1); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } /* If either side can only do a partial bridge, then don't try for a true native bridge */ if (audio_p0_res == AST_RTP_TRY_PARTIAL || audio_p1_res == AST_RTP_TRY_PARTIAL) { /* In order to do Packet2Packet bridging both sides must be in the same rawread/rawwrite */ if (c0->rawreadformat != c1->rawwriteformat || c1->rawreadformat != c0->rawwriteformat) { if (option_debug) ast_log(LOG_DEBUG, "Cannot packet2packet bridge - raw formats are incompatible\n"); ast_channel_unlock(c0); ast_channel_unlock(c1); return AST_BRIDGE_FAILED_NOWARN; } if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Packet2Packet bridging %s and %s\n", c0->name, c1->name); res = bridge_p2p_loop(c0, c1, p0, p1, timeoutms, flags, fo, rc, pvt0, pvt1); } else { if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name); res = bridge_native_loop(c0, c1, p0, p1, vp0, vp1, pr0, pr1, codec0, codec1, timeoutms, flags, fo, rc, pvt0, pvt1); } return res; }

int ast_rtp_codec_getformat (  int  pt  )

get format from predefined dynamic payload format Definition at line 2711 of file rtp.c. References rtpPayloadType::code, MAX_RTP_PT, and static_RTP_PT. { if (pt < 0 || pt > MAX_RTP_PT) return 0; /* bogus payload type */ if (static_RTP_PT[pt].isAstFormat) return static_RTP_PT[pt].code; else return 0; }

struct ast_codec_pref* ast_rtp_codec_getpref (  struct ast_rtp *  rtp  )

Get codec preference Definition at line 2706 of file rtp.c. References ast_rtp::pref. Referenced by add_codec_to_sdp(). { return &rtp->pref; }

int ast_rtp_codec_setpref (  struct ast_rtp *  rtp, struct ast_codec_pref *  prefs )

Set codec preference Definition at line 2693 of file rtp.c. References ast_codec_pref::framing, ast_codec_pref::order, ast_rtp::pref, and prefs. Referenced by __oh323_rtp_create(), check_peer_ok(), check_user_full(), check_user_ok(), create_addr_from_peer(), register_verify(), set_peer_capabilities(), start_rtp(), transmit_response_with_attachment(), and transmit_response_with_sdp(). { int x; for (x = 0; x < 32; x++) { /* Ugly way */ rtp->pref.order[x] = prefs->order[x]; rtp->pref.framing[x] = prefs->framing[x]; } if (rtp->smoother) ast_smoother_free(rtp->smoother); rtp->smoother = NULL; return 0; }

void ast_rtp_destroy (  struct ast_rtp *  rtp  )

Destroy RTP session Definition at line 2111 of file rtp.c. References ast_io_remove(), ast_mutex_destroy(), ast_sched_del(), ast_smoother_free(), ast_verbose(), ast_rtcp::expected_prior, free, ast_rtp::io, ast_rtp::ioid, ast_rtcp::received_prior, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtcp::rr_count, ast_rtp::rtcp, rtcp_debug_test_addr(), rtcpstats, ast_rtcp::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::rxtransit, ast_rtp::s, ast_rtcp::s, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::smoother, ast_rtcp::sr_count, ast_rtp::ssrc, ast_rtp::them, ast_rtp::themssrc, and ast_rtp::txcount. Referenced by __oh323_destroy(), __sip_destroy(), check_peer_ok(), check_user_full(), check_user_ok(), cleanup_connection(), create_addr_from_peer(), gtalk_free_pvt(), jingle_free_pvt(), mgcp_hangup(), oh323_alloc(), skinny_hangup(), start_rtp(), and unalloc_sub(). { if (rtcp_debug_test_addr(&rtp->them) || rtcpstats) { /*Print some info on the call here */ ast_verbose(" RTP-stats\n"); ast_verbose("* Our Receiver:\n"); ast_verbose(" SSRC: %u\n", rtp->themssrc); ast_verbose(" Received packets: %u\n", rtp->rxcount); ast_verbose(" Lost packets: %u\n", rtp->rtcp->expected_prior - rtp->rtcp->received_prior); ast_verbose(" Jitter: %.4f\n", rtp->rxjitter); ast_verbose(" Transit: %.4f\n", rtp->rxtransit); ast_verbose(" RR-count: %u\n", rtp->rtcp->rr_count); ast_verbose("* Our Sender:\n"); ast_verbose(" SSRC: %u\n", rtp->ssrc); ast_verbose(" Sent packets: %u\n", rtp->txcount); ast_verbose(" Lost packets: %u\n", rtp->rtcp->reported_lost); ast_verbose(" Jitter: %u\n", rtp->rtcp->reported_jitter); ast_verbose(" SR-count: %u\n", rtp->rtcp->sr_count); ast_verbose(" RTT: %f\n", rtp->rtcp->rtt); } if (rtp->smoother) ast_smoother_free(rtp->smoother); if (rtp->ioid) ast_io_remove(rtp->io, rtp->ioid); if (rtp->s > -1) close(rtp->s); if (rtp->rtcp) { if (rtp->rtcp->schedid > 0) ast_sched_del(rtp->sched, rtp->rtcp->schedid); close(rtp->rtcp->s); free(rtp->rtcp); rtp->rtcp=NULL; } #ifdef P2P_INTENSE ast_mutex_destroy(&rtp->bridge_lock); #endif free(rtp); }

int ast_rtp_early_bridge (  struct ast_channel *  c0, struct ast_channel *  c1 )

If possible, create an early bridge directly between the devices without having to send a re-invite later. Definition at line 1522 of file rtp.c. References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer. { // dest = c0, src = c1 struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; int srccodec, nat_active = 0; /* Lock channels */ ast_channel_lock(c0); if (c1) { while (ast_channel_trylock(c1)) { ast_channel_unlock(c0); usleep(1); ast_channel_lock(c0); } } /* Find channel driver interfaces */ destpr = get_proto(c0); if (c1) srcpr = get_proto(c1); if (!destpr) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c0->name); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } if (!srcpr) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", c1 ? c1->name : "<unspecified>"); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } /* Get audio and video interface (if native bridge is possible) */ audio_dest_res = destpr->get_rtp_info(c0, &destp); video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(c0, &vdestp) : AST_RTP_GET_FAILED; if (srcpr) { audio_src_res = srcpr->get_rtp_info(c1, &srcp); video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(c1, &vsrcp) : AST_RTP_GET_FAILED; } /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ if (audio_dest_res != AST_RTP_TRY_NATIVE) { /* Somebody doesn't want to play... */ ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); return -1; } if (audio_src_res == AST_RTP_TRY_NATIVE && srcpr->get_codec) srccodec = srcpr->get_codec(c1); else srccodec = 0; /* Consider empty media as non-existant */ if (audio_src_res == AST_RTP_TRY_NATIVE && !srcp->them.sin_addr.s_addr) srcp = NULL; if (srcp && (srcp->nat || ast_test_flag(srcp, FLAG_NAT_ACTIVE))) nat_active = 1; /* Bridge media early */ if (destpr->set_rtp_peer(c0, srcp, vsrcp, srccodec, nat_active)) ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", c0->name, c1 ? c1->name : "<unspecified>"); ast_channel_unlock(c0); if (c1) ast_channel_unlock(c1); if (option_debug) ast_log(LOG_DEBUG, "Setting early bridge SDP of '%s' with that of '%s'\n", c0->name, c1 ? c1->name : "<unspecified>"); return 0; }

int ast_rtp_fd (  struct ast_rtp *  rtp  )

Definition at line 514 of file rtp.c. References ast_rtp::s. Referenced by __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), gtalk_new(), jingle_new(), mgcp_new(), p2p_callback_disable(), sip_new(), skinny_new(), and start_rtp(). { return rtp->s; }

struct ast_rtp* ast_rtp_get_bridged (  struct ast_rtp *  rtp  )

Definition at line 2045 of file rtp.c. References ast_rtp::bridged, rtp_bridge_lock(), and rtp_bridge_unlock(). Referenced by ast_rtp_read(), and check_rtp_timeout(). { struct ast_rtp *bridged = NULL; rtp_bridge_lock(rtp); bridged = rtp->bridged; rtp_bridge_unlock(rtp); return bridged; }

void ast_rtp_get_current_formats (  struct ast_rtp *  rtp, int *  astFormats, int *  nonAstFormats )

Return the union of all of the codecs that were set by rtp_set...() calls They're returned as two distinct sets: AST_FORMATs, and AST_RTPs. Definition at line 1711 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by process_sdp(). { int pt; rtp_bridge_lock(rtp); *astFormats = *nonAstFormats = 0; for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (rtp->current_RTP_PT[pt].isAstFormat) { *astFormats |= rtp->current_RTP_PT[pt].code; } else { *nonAstFormats |= rtp->current_RTP_PT[pt].code; } } rtp_bridge_unlock(rtp); return; }

int ast_rtp_get_peer (  struct ast_rtp *  rtp, struct sockaddr_in *  them )

Definition at line 2027 of file rtp.c. References ast_rtp::them. Referenced by add_sdp(), bridge_native_loop(), check_rtp_timeout(), oh323_set_rtp_peer(), sip_set_rtp_peer(), and transmit_modify_with_sdp(). { if ((them->sin_family != AF_INET) || (them->sin_port != rtp->them.sin_port) || (them->sin_addr.s_addr != rtp->them.sin_addr.s_addr)) { them->sin_family = AF_INET; them->sin_port = rtp->them.sin_port; them->sin_addr = rtp->them.sin_addr; return 1; } return 0; }

char* ast_rtp_get_quality (  struct ast_rtp *  rtp  )

Definition at line 2093 of file rtp.c. References ast_rtcp::expected_prior, ast_rtcp::quality, ast_rtcp::received_prior, ast_rtcp::reported_jitter, ast_rtcp::reported_lost, ast_rtp::rtcp, ast_rtcp::rtt, ast_rtp::rxcount, ast_rtp::rxjitter, ast_rtp::ssrc, ast_rtp::themssrc, and ast_rtp::txcount. Referenced by handle_request_bye(), and sip_hangup(). { /* *ssrc our ssrc *themssrc their ssrc *lp lost packets *rxjitter our calculated jitter(rx) *rxcount no. received packets *txjitter reported jitter of the other end *txcount transmitted packets *rlp remote lost packets */ snprintf(rtp->rtcp->quality, sizeof(rtp->rtcp->quality), "ssrc=%u;themssrc=%u;lp=%u;rxjitter=%f;rxcount=%u;txjitter=%f;txcount=%u;rlp=%u;rtt=%f", rtp->ssrc, rtp->themssrc, rtp->rtcp->expected_prior - rtp->rtcp->received_prior, rtp->rxjitter, rtp->rxcount, (double)rtp->rtcp->reported_jitter/65536., rtp->txcount, rtp->rtcp->reported_lost, rtp->rtcp->rtt); return rtp->rtcp->quality; }

int ast_rtp_get_rtpholdtimeout (  struct ast_rtp *  rtp  )

Get rtp hold timeout. Definition at line 569 of file rtp.c. References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout. Referenced by check_rtp_timeout(). { if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ return 0; return rtp->rtpholdtimeout; }

int ast_rtp_get_rtpkeepalive (  struct ast_rtp *  rtp  )

Get RTP keepalive interval. Definition at line 577 of file rtp.c. References ast_rtp::rtpkeepalive. Referenced by check_rtp_timeout(). { return rtp->rtpkeepalive; }

int ast_rtp_get_rtptimeout (  struct ast_rtp *  rtp  )

Get rtp timeout. Definition at line 561 of file rtp.c. References ast_rtp::rtptimeout. Referenced by check_rtp_timeout(). { if (rtp->rtptimeout < 0) /* We're not checking, but remembering the setting (during T.38 transmission) */ return 0; return rtp->rtptimeout; }

void ast_rtp_get_us (  struct ast_rtp *  rtp, struct sockaddr_in *  us )

Definition at line 2040 of file rtp.c. References ast_rtp::us. Referenced by add_sdp(), external_rtp_create(), get_our_media_address(), handle_open_receive_channel_ack_message(), and oh323_set_rtp_peer(). { *us = rtp->us; }

int ast_rtp_getnat (  struct ast_rtp *  rtp  )

Definition at line 597 of file rtp.c. References ast_test_flag, and FLAG_NAT_ACTIVE. Referenced by sip_get_rtp_peer(). { return ast_test_flag(rtp, FLAG_NAT_ACTIVE); }

void ast_rtp_init (  void   )

Return RTCP quality string. Definition at line 3664 of file rtp.c. References ast_cli_register_multiple(), ast_rtp_reload(), and cli_rtp. { ast_cli_register_multiple(cli_rtp, sizeof(cli_rtp) / sizeof(struct ast_cli_entry)); ast_rtp_reload(); }

int ast_rtp_lookup_code (  struct ast_rtp *  rtp, const int  isAstFormat, const int  code )

Looks up an RTP code out of our *static* outbound list. Definition at line 1754 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, rtp_bridge_lock(), rtp_bridge_unlock(), ast_rtp::rtp_lookup_code_cache_code, ast_rtp::rtp_lookup_code_cache_isAstFormat, and ast_rtp::rtp_lookup_code_cache_result. Referenced by add_codec_to_answer(), add_codec_to_sdp(), add_noncodec_to_sdp(), ast_rtp_sendcng(), ast_rtp_senddigit_begin(), ast_rtp_write(), and bridge_p2p_rtp_write(). { int pt = 0; rtp_bridge_lock(rtp); if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat && code == rtp->rtp_lookup_code_cache_code) { /* Use our cached mapping, to avoid the overhead of the loop below */ pt = rtp->rtp_lookup_code_cache_result; rtp_bridge_unlock(rtp); return pt; } /* Check the dynamic list first */ for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) { rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; rtp->rtp_lookup_code_cache_code = code; rtp->rtp_lookup_code_cache_result = pt; rtp_bridge_unlock(rtp); return pt; } } /* Then the static list */ for (pt = 0; pt < MAX_RTP_PT; ++pt) { if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) { rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat; rtp->rtp_lookup_code_cache_code = code; rtp->rtp_lookup_code_cache_result = pt; rtp_bridge_unlock(rtp); return pt; } } rtp_bridge_unlock(rtp); return -1; }

char* ast_rtp_lookup_mime_multiple (  char *  buf, size_t  size, const int  capability, const int  isAstFormat, enum ast_rtp_options  options )

Build a string of MIME subtype names from a capability list. Definition at line 1814 of file rtp.c. References ast_rtp_lookup_mime_subtype(), AST_RTP_MAX, format, len, and name. { int format; unsigned len; char *end = buf; char *start = buf; if (!buf || !size) return NULL; snprintf(end, size, "0x%x (", capability); len = strlen(end); end += len; size -= len; start = end; for (format = 1; format < AST_RTP_MAX; format <<= 1) { if (capability & format) { const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format, options); snprintf(end, size, "%s|", name); len = strlen(end); end += len; size -= len; } } if (start == end) snprintf(start, size, "nothing)"); else if (size > 1) *(end -1) = ')'; return buf; }

const char* ast_rtp_lookup_mime_subtype (  const int  isAstFormat, const int  code, enum ast_rtp_options  options )

Mapping an Asterisk code into a MIME subtype (string):. Definition at line 1795 of file rtp.c. References AST_FORMAT_G726_AAL2, AST_RTP_OPT_G726_NONSTANDARD, rtpPayloadType::code, mimeTypes, and payloadType. Referenced by add_codec_to_sdp(), add_noncodec_to_sdp(), ast_rtp_lookup_mime_multiple(), transmit_connect_with_sdp(), and transmit_modify_with_sdp(). { unsigned int i; for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { if ((mimeTypes[i].payloadType.code == code) && (mimeTypes[i].payloadType.isAstFormat == isAstFormat)) { if (isAstFormat && (code == AST_FORMAT_G726_AAL2) && (options & AST_RTP_OPT_G726_NONSTANDARD)) return "G726-32"; else return mimeTypes[i].subtype; } } return ""; }

struct rtpPayloadType ast_rtp_lookup_pt (  struct ast_rtp *  rtp, int  pt )

Mapping between RTP payload format codes and Asterisk codes:. Definition at line 1732 of file rtp.c. Referenced by ast_rtp_read(), bridge_p2p_rtp_write(), and setup_rtp_connection(). { struct rtpPayloadType result; result.isAstFormat = result.code = 0; if (pt < 0 || pt > MAX_RTP_PT) return result; /* bogus payload type */ /* Start with negotiated codecs */ rtp_bridge_lock(rtp); result = rtp->current_RTP_PT[pt]; rtp_bridge_unlock(rtp); /* If it doesn't exist, check our static RTP type list, just in case */ if (!result.code) result = static_RTP_PT[pt]; return result; }

int ast_rtp_make_compatible (  struct ast_channel *  dest, struct ast_channel *  src, int  media )

Definition at line 1599 of file rtp.c. References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_log(), AST_RTP_GET_FAILED, ast_rtp_pt_copy(), AST_RTP_TRY_NATIVE, ast_test_flag, FLAG_NAT_ACTIVE, get_proto(), ast_rtp_protocol::get_rtp_info, ast_rtp_protocol::get_vrtp_info, LOG_DEBUG, LOG_WARNING, option_debug, and ast_rtp_protocol::set_rtp_peer. { struct ast_rtp *destp = NULL, *srcp = NULL; /* Audio RTP Channels */ struct ast_rtp *vdestp = NULL, *vsrcp = NULL; /* Video RTP channels */ struct ast_rtp_protocol *destpr = NULL, *srcpr = NULL; enum ast_rtp_get_result audio_dest_res = AST_RTP_GET_FAILED, video_dest_res = AST_RTP_GET_FAILED; enum ast_rtp_get_result audio_src_res = AST_RTP_GET_FAILED, video_src_res = AST_RTP_GET_FAILED; int srccodec; /* Lock channels */ ast_channel_lock(dest); while (ast_channel_trylock(src)) { ast_channel_unlock(dest); usleep(1); ast_channel_lock(dest); } /* Find channel driver interfaces */ if (!(destpr = get_proto(dest))) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", dest->name); ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } if (!(srcpr = get_proto(src))) { if (option_debug) ast_log(LOG_DEBUG, "Channel '%s' has no RTP, not doing anything\n", src->name); ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } /* Get audio and video interface (if native bridge is possible) */ audio_dest_res = destpr->get_rtp_info(dest, &destp); video_dest_res = destpr->get_vrtp_info ? destpr->get_vrtp_info(dest, &vdestp) : AST_RTP_GET_FAILED; audio_src_res = srcpr->get_rtp_info(src, &srcp); video_src_res = srcpr->get_vrtp_info ? srcpr->get_vrtp_info(src, &vsrcp) : AST_RTP_GET_FAILED; /* Check if bridge is still possible (In SIP canreinvite=no stops this, like NAT) */ if (audio_dest_res != AST_RTP_TRY_NATIVE || audio_src_res != AST_RTP_TRY_NATIVE) { /* Somebody doesn't want to play... */ ast_channel_unlock(dest); ast_channel_unlock(src); return 0; } ast_rtp_pt_copy(destp, srcp); if (vdestp && vsrcp) ast_rtp_pt_copy(vdestp, vsrcp); if (srcpr->get_codec) srccodec = srcpr->get_codec(src); else srccodec = 0; if (media) { /* Bridge early */ if (destpr->set_rtp_peer(dest, srcp, vsrcp, srccodec, ast_test_flag(srcp, FLAG_NAT_ACTIVE))) ast_log(LOG_WARNING, "Channel '%s' failed to setup early bridge to '%s'\n", dest->name, src->name); } ast_channel_unlock(dest); ast_channel_unlock(src); if (option_debug) ast_log(LOG_DEBUG, "Seeded SDP of '%s' with that of '%s'\n", dest->name, src->name); return 1; }

struct ast_rtp* ast_rtp_new (  struct sched_context *  sched, struct io_context *  io, int  rtcpenable, int  callbackmode )

Initializate a RTP session. Parameters: sched  io  rtcpenable  callbackmode  Returns: A representation (structure) of an RTP session. Definition at line 1999 of file rtp.c. References ast_rtp_new_with_bindaddr(), io, and sched. { struct in_addr ia; memset(&ia, 0, sizeof(ia)); return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia); }

void ast_rtp_new_init (  struct ast_rtp *  rtp  )

Initialize a new RTP structure. reload rtp configuration Definition at line 1896 of file rtp.c. References ast_mutex_init(), ast_random(), ast_set_flag, FLAG_HAS_DTMF, ast_rtp::seqno, ast_rtp::ssrc, ast_rtp::them, and ast_rtp::us. Referenced by ast_rtp_new_with_bindaddr(), and process_sdp(). { #ifdef P2P_INTENSE ast_mutex_init(&rtp->bridge_lock); #endif rtp->them.sin_family = AF_INET; rtp->us.sin_family = AF_INET; rtp->ssrc = ast_random(); rtp->seqno = ast_random() & 0xffff; ast_set_flag(rtp, FLAG_HAS_DTMF); return; }

struct ast_rtp* ast_rtp_new_with_bindaddr (  struct sched_context *  sched, struct io_context *  io, int  rtcpenable, int  callbackmode, struct in_addr  in )

Initializate a RTP session using an in_addr structure. This fuction gets called by ast_rtp_new(). Parameters: sched  io  rtcpenable  callbackmode  in  Returns: A representation (structure) of an RTP session. Definition at line 1911 of file rtp.c. References ast_calloc, ast_log(), ast_random(), ast_rtcp_new(), ast_rtp_new_init(), free, LOG_ERROR, rtp_socket(), rtpend, rtpstart, and sched. Referenced by __oh323_rtp_create(), ast_rtp_new(), dialog_activate_media(), gtalk_alloc(), jingle_alloc(), sip_alloc(), and start_rtp(). { struct ast_rtp *rtp; int x; int first; int startplace; if (!(rtp = ast_calloc(1, sizeof(*rtp)))) return NULL; ast_rtp_new_init(rtp); rtp->s = rtp_socket(); if (rtp->s < 0) { free(rtp); ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno)); return NULL; } if (sched && rtcpenable) { rtp->sched = sched; rtp->rtcp = ast_rtcp_new(); } /* Select a random port number in the range of possible RTP */ x = (ast_random() % (rtpend-rtpstart)) + rtpstart; x = x & ~1; /* Save it for future references. */ startplace = x; /* Iterate tring to bind that port and incrementing it otherwise untill a port was found or no ports are available. */ for (;;) { /* Must be an even port number by RTP spec */ rtp->us.sin_port = htons(x); rtp->us.sin_addr = addr; /* If there's rtcp, initialize it as well. */ if (rtp->rtcp) { rtp->rtcp->us.sin_port = htons(x + 1); rtp->rtcp->us.sin_addr = addr; } /* Try to bind it/them. */ if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) && (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us)))) break; if (!first) { /* Primary bind succeeded! Gotta recreate it */ close(rtp->s); rtp->s = rtp_socket(); } if (errno != EADDRINUSE) { /* We got an error that wasn't expected, abort! */ ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno)); close(rtp->s); if (rtp->rtcp) { close(rtp->rtcp->s); free(rtp->rtcp); } free(rtp); return NULL; } /* The port was used, increment it (by two). */ x += 2; /* Did we go over the limit ? */ if (x > rtpend) /* then, start from the begingig. */ x = (rtpstart + 1) & ~1; /* Check if we reached the place were we started. */ if (x == startplace) { /* If so, there's no ports available. */ ast_log(LOG_ERROR, "No RTP ports remaining. Can't setup media stream for this call.\n"); close(rtp->s); if (rtp->rtcp) { close(rtp->rtcp->s); free(rtp->rtcp); } free(rtp); return NULL; } } rtp->sched = sched; rtp->io = io; if (callbackmode) { rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp); ast_set_flag(rtp, FLAG_CALLBACK_MODE); } ast_rtp_pt_default(rtp); return rtp; }

int ast_rtp_proto_register (  struct ast_rtp_protocol *  proto  )

Register an RTP channel client. Definition at line 2809 of file rtp.c. References ast_log(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, LOG_WARNING, protos, and ast_rtp_protocol::type. Referenced by load_module(), and register_rtp_and_udptl(). { struct ast_rtp_protocol *cur; AST_RWLIST_WRLOCK(&protos); AST_RWLIST_TRAVERSE(&protos, cur, list) { if (!strcmp(cur->type, proto->type)) { ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type); AST_RWLIST_UNLOCK(&protos); return -1; } } AST_RWLIST_INSERT_HEAD(&protos, proto, list); AST_RWLIST_UNLOCK(&protos); return 0; }

void ast_rtp_proto_unregister (  struct ast_rtp_protocol *  proto  )

Unregister an RTP channel client. Definition at line 2801 of file rtp.c. References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and protos. Referenced by load_module(), unload_module(), and unregister_rtp_and_udptl(). { AST_RWLIST_WRLOCK(&protos); AST_RWLIST_REMOVE(&protos, proto, list); AST_RWLIST_UNLOCK(&protos); }

void ast_rtp_pt_clear (  struct ast_rtp *  rtp  )

Setting RTP payload types from lines in a SDP description:. Definition at line 1446 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by process_sdp(). { int i; if (!rtp) return; rtp_bridge_lock(rtp); for (i = 0; i < MAX_RTP_PT; ++i) { rtp->current_RTP_PT[i].isAstFormat = 0; rtp->current_RTP_PT[i].code = 0; } rtp->rtp_lookup_code_cache_isAstFormat = 0; rtp->rtp_lookup_code_cache_code = 0; rtp->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(rtp); }

void ast_rtp_pt_copy (  struct ast_rtp *  dest, struct ast_rtp *  src )

Copy payload types between RTP structures. Definition at line 1486 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, and rtp_bridge_lock(). Referenced by ast_rtp_make_compatible(). { unsigned int i; rtp_bridge_lock(dest); rtp_bridge_lock(src); for (i=0; i < MAX_RTP_PT; ++i) { dest->current_RTP_PT[i].isAstFormat = src->current_RTP_PT[i].isAstFormat; dest->current_RTP_PT[i].code = src->current_RTP_PT[i].code; } dest->rtp_lookup_code_cache_isAstFormat = 0; dest->rtp_lookup_code_cache_code = 0; dest->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(src); rtp_bridge_unlock(dest); }

void ast_rtp_pt_default (  struct ast_rtp *  rtp  )

Set payload types to defaults. Definition at line 1467 of file rtp.c. References rtpPayloadType::code, ast_rtp::current_RTP_PT, rtpPayloadType::isAstFormat, MAX_RTP_PT, rtp_bridge_lock(), and static_RTP_PT. { int i; rtp_bridge_lock(rtp); /* Initialize to default payload types */ for (i = 0; i < MAX_RTP_PT; ++i) { rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat; rtp->current_RTP_PT[i].code = static_RTP_PT[i].code; } rtp->rtp_lookup_code_cache_isAstFormat = 0; rtp->rtp_lookup_code_cache_code = 0; rtp->rtp_lookup_code_cache_result = 0; rtp_bridge_unlock(rtp); }

static int ast_rtp_raw_write (  struct ast_rtp *  rtp, struct ast_frame *  f, int  codec )  [static]

Write RTP packet with audio or video media frames into UDP packet. Definition at line 2603 of file rtp.c. References AST_FORMAT_MAX_AUDIO, ast_inet_ntoa(), ast_log(), ast_rtcp_calc_interval(), ast_rtcp_write(), ast_sched_add(), ast_set_flag, ast_test_flag, ast_verbose(), calc_txstamp(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, ast_rtp::f, FLAG_NAT_ACTIVE, FLAG_NAT_INACTIVE, FLAG_NAT_INACTIVE_NOWARN, ast_frame::has_timing_info, ast_rtp::lastdigitts, ast_rtp::lastovidtimestamp, ast_rtp::lastts, LOG_DEBUG, MAX_TIMESTAMP_SKEW, ast_rtp::nat, option_debug, put_unaligned_uint32(), ast_rtp::rtcp, rtp_debug_test_addr(), rtpdebug, ast_rtp::s, ast_frame::samples, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seqno, ast_rtp::ssrc, ast_frame::subclass, ast_rtp::them, ast_frame::ts, ast_rtp::txcount, and ast_rtp::txoctetcount. Referenced by ast_rtp_write(). { unsigned char *rtpheader; int hdrlen = 12; int res; unsigned int ms; int pred; int mark = 0; ms = calc_txstamp(rtp, &f->delivery); /* Default prediction */ if (f->subclass < AST_FORMAT_MAX_AUDIO) { pred = rtp->lastts + f->samples; /* Re-calculate last TS */ rtp->lastts = rtp->lastts + ms * 8; if (ast_tvzero(f->delivery)) { /* If this isn't an absolute delivery time, Check if it is close to our prediction, and if so, go with our prediction */ if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW) rtp->lastts = pred; else { if (option_debug > 2) ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms); mark = 1; } } } else { mark = f->subclass & 0x1; pred = rtp->lastovidtimestamp + f->samples; /* Re-calculate last TS */ rtp->lastts = rtp->lastts + ms * 90; /* If it's close to our prediction, go for it */ if (ast_tvzero(f->delivery)) { if (abs(rtp->lastts - pred) < 7200) { rtp->lastts = pred; rtp->lastovidtimestamp += f->samples; } else { if (option_debug > 2) 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); rtp->lastovidtimestamp = rtp->lastts; } } } /* If the timestamp for non-digit packets has moved beyond the timestamp for digits, update the digit timestamp. */ if (rtp->lastts > rtp->lastdigitts) rtp->lastdigitts = rtp->lastts; if (f->has_timing_info) rtp->lastts = f->ts * 8; /* Get a pointer to the header */ rtpheader = (unsigned char *)(f->data - hdrlen); put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23))); put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts)); put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc)); if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) { res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them)); if (res <0) { if (!rtp->nat || (rtp->nat && (ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_ACTIVE))) { if (option_debug) 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)); } else if (((ast_test_flag(rtp, FLAG_NAT_ACTIVE) == FLAG_NAT_INACTIVE) || rtpdebug) && !ast_test_flag(rtp, FLAG_NAT_INACTIVE_NOWARN)) { /* Only give this error message once if we are not RTP debugging */ if (option_debug || rtpdebug) 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)); ast_set_flag(rtp, FLAG_NAT_INACTIVE_NOWARN); } } else { rtp->txcount++; rtp->txoctetcount +=(res - hdrlen); if (rtp->rtcp && rtp->rtcp->schedid < 1) rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp); } if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent RTP packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen); } rtp->seqno++; return 0; }

struct ast_frame* ast_rtp_read (  struct ast_rtp *  rtp  )

Definition at line 1144 of file rtp.c. References ast_codec_get_samples(), AST_FORMAT_MAX_AUDIO, AST_FORMAT_SLINEAR, ast_frame_byteswap_be, AST_FRAME_VIDEO, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_inet_ntoa(), ast_log(), ast_null_frame, ast_rtcp_calc_interval(), ast_rtcp_write(), AST_RTP_CISCO_DTMF, AST_RTP_CN, AST_RTP_DTMF, ast_rtp_get_bridged(), ast_rtp_lookup_pt(), ast_rtp_senddigit_continuation(), ast_sched_add(), ast_set_flag, ast_verbose(), bridge_p2p_rtp_write(), ast_rtp::bridged, calc_rxstamp(), rtpPayloadType::code, CRASH, ast_rtp::cycles, ast_frame::data, ast_frame::datalen, ast_frame::delivery, event, ext, ast_rtp::f, FLAG_NAT_ACTIVE, ast_frame::frametype, ast_frame::has_timing_info, rtpPayloadType::isAstFormat, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxseqno, ast_rtp::lastrxts, len, ast_frame::len, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, ast_rtp::nat, ast_frame::offset, option_debug, process_cisco_dtmf(), process_rfc2833(), process_rfc3389(), ast_rtp::rawdata, ast_rtp::rtcp, rtp_debug_test_addr(), RTP_SEQ_MOD, ast_rtp::rxcount, ast_rtp::rxseqno, ast_rtp::rxssrc, ast_rtp::s, ast_frame::samples, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::seedrxseqno, ast_rtp::sending_digit, ast_frame::seqno, ast_frame::src, STUN_ACCEPT, stun_handle_packet(), ast_frame::subclass, ast_rtp::them, ast_rtcp::them, ast_rtp::themssrc, and ast_frame::ts. Referenced by gtalk_rtp_read(), jingle_rtp_read(), mgcp_rtp_read(), oh323_rtp_read(), rtpread(), sip_rtp_read(), and skinny_rtp_read(). { int res; struct sockaddr_in sin; socklen_t len; unsigned int seqno; int version; int payloadtype; int tseqno; int hdrlen = 12; int padding; int mark; int ext; unsigned int ssrc; unsigned int timestamp; unsigned int *rtpheader; struct rtpPayloadType rtpPT; struct ast_rtp *bridged = NULL; /* If time is up, kill it */ if (rtp->sending_digit) ast_rtp_senddigit_continuation(rtp); len = sizeof(sin); /* Cache where the header will go */ res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET, 0, (struct sockaddr *)&sin, &len); rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET); if (res < 0) { if (errno != EAGAIN) ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno)); if (errno == EBADF) CRASH; return &ast_null_frame; } if (res < hdrlen) { ast_log(LOG_WARNING, "RTP Read too short\n"); return &ast_null_frame; } /* Get fields */ seqno = ntohl(rtpheader[0]); /* Check RTP version */ version = (seqno & 0xC0000000) >> 30; if (!version) { if ((stun_handle_packet(rtp->s, &sin, rtp->rawdata + AST_FRIENDLY_OFFSET, res) == STUN_ACCEPT) && (!rtp->them.sin_port && !rtp->them.sin_addr.s_addr)) { memcpy(&rtp->them, &sin, sizeof(rtp->them)); } return &ast_null_frame; } #if 0 /* Allow to receive RTP stream with closed transmission path */ /* If we don't have the other side's address, then ignore this */ if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return &ast_null_frame; #endif /* Send to whoever send to us if NAT is turned on */ if (rtp->nat) { if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) || (rtp->them.sin_port != sin.sin_port)) { rtp->them = sin; if (rtp->rtcp) { memcpy(&rtp->rtcp->them, &sin, sizeof(rtp->rtcp->them)); rtp->rtcp->them.sin_port = htons(ntohs(rtp->them.sin_port)+1); } rtp->rxseqno = 0; ast_set_flag(rtp, FLAG_NAT_ACTIVE); if (option_debug || rtpdebug) 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)); } } /* If we are bridged to another RTP stream, send direct */ if ((bridged = ast_rtp_get_bridged(rtp)) && !bridge_p2p_rtp_write(rtp, bridged, rtpheader, res, hdrlen)) return &ast_null_frame; if (version != 2) return &ast_null_frame; payloadtype = (seqno & 0x7f0000) >> 16; padding = seqno & (1 << 29); mark = seqno & (1 << 23); ext = seqno & (1 << 28); seqno &= 0xffff; timestamp = ntohl(rtpheader[1]); ssrc = ntohl(rtpheader[2]); if (!mark && rtp->rxssrc && rtp->rxssrc != ssrc) { if (option_debug || rtpdebug) ast_log(LOG_DEBUG, "Forcing Marker bit, because SSRC has changed\n"); mark = 1; } rtp->rxssrc = ssrc; if (padding) { /* Remove padding bytes */ res -= rtp->rawdata[AST_FRIENDLY_OFFSET + res - 1]; } if (ext) { /* RTP Extension present */ hdrlen += 4; hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2; if (option_debug) { int profile; profile = (ntohl(rtpheader[3]) & 0xffff0000) >> 16; if (profile == 0x505a) ast_log(LOG_DEBUG, "Found Zfone extension in RTP stream - zrtp - not supported.\n"); else ast_log(LOG_DEBUG, "Found unknown RTP Extensions %x\n", profile); } } if (res < hdrlen) { ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen); return &ast_null_frame; } rtp->rxcount++; /* Only count reasonably valid packets, this'll make the rtcp stats more accurate */ tseqno = rtp->lastrxseqno +1; if (rtp->rxcount==1) { /* This is the first RTP packet successfully received from source */ rtp->seedrxseqno = seqno; } /* Do not schedule RR if RTCP isn't run */ if (rtp->rtcp && rtp->rtcp->them.sin_addr.s_addr && rtp->rtcp->schedid < 1) { /* Schedule transmission of Receiver Report */ rtp->rtcp->schedid = ast_sched_add(rtp->sched, ast_rtcp_calc_interval(rtp), ast_rtcp_write, rtp); } if (tseqno > RTP_SEQ_MOD) { /* if tseqno is greater than RTP_SEQ_MOD it would indicate that the sender cycled */ rtp->cycles += RTP_SEQ_MOD; ast_verbose("SEQNO cycled: %u\t%d\n", rtp->cycles, seqno); } rtp->lastrxseqno = seqno; if (rtp->themssrc==0) rtp->themssrc = ntohl(rtpheader[2]); /* Record their SSRC to put in future RR */ if (rtp_debug_test_addr(&sin)) ast_verbose("Got RTP packet from %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen); rtpPT = ast_rtp_lookup_pt(rtp, payloadtype); if (!rtpPT.isAstFormat) { struct ast_frame *f = NULL; /* This is special in-band data that's not one of our codecs */ if (rtpPT.code == AST_RTP_DTMF) { /* It's special -- rfc2833 process it */ if (rtp_debug_test_addr(&sin)) { unsigned char *data; unsigned int event; unsigned int event_end; unsigned int duration; data = rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen; event = ntohl(*((unsigned int *)(data))); event >>= 24; event_end = ntohl(*((unsigned int *)(data))); event_end <<= 8; event_end >>= 24; duration = ntohl(*((unsigned int *)(data))); duration &= 0xFFFF; 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); } f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen, seqno); } else if (rtpPT.code == AST_RTP_CISCO_DTMF) { /* It's really special -- process it the Cisco way */ if (rtp->lasteventseqn <= seqno || (rtp->lasteventseqn >= 65530 && seqno <= 6)) { f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); rtp->lasteventseqn = seqno; } } else if (rtpPT.code == AST_RTP_CN) { /* Comfort Noise */ f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen); } else { ast_log(LOG_NOTICE, "Unknown RTP codec %d received from '%s'\n", payloadtype, ast_inet_ntoa(rtp->them.sin_addr)); } return f ? f : &ast_null_frame; } rtp->lastrxformat = rtp->f.subclass = rtpPT.code; rtp->f.frametype = (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) ? AST_FRAME_VOICE : AST_FRAME_VIDEO; if (!rtp->lastrxts) rtp->lastrxts = timestamp; rtp->rxseqno = seqno; /* Record received timestamp as last received now */ rtp->lastrxts = timestamp; rtp->f.mallocd = 0; rtp->f.datalen = res - hdrlen; rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET; rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET; if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) { rtp->f.samples = ast_codec_get_samples(&rtp->f); if (rtp->f.subclass == AST_FORMAT_SLINEAR) ast_frame_byteswap_be(&rtp->f); calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark); /* Add timing data to let ast_generic_bridge() put the frame into a jitterbuf */ rtp->f.has_timing_info = 1; rtp->f.ts = timestamp / 8; rtp->f.len = rtp->f.samples / 8; rtp->f.seqno = seqno; } else { /* Video -- samples is # of samples vs. 90000 */ if (!rtp->lastividtimestamp) rtp->lastividtimestamp = timestamp; rtp->f.samples = timestamp - rtp->lastividtimestamp; rtp->lastividtimestamp = timestamp; rtp->f.delivery.tv_sec = 0; rtp->f.delivery.tv_usec = 0; if (mark) rtp->f.subclass |= 0x1; } rtp->f.src = "RTP"; return &rtp->f; }

int ast_rtp_reload (  void   )

Initialize RTP subsystem Definition at line 3599 of file rtp.c. References ast_config_destroy(), ast_config_load(), ast_false(), ast_log(), ast_variable_retrieve(), ast_verbose(), DEFAULT_DTMF_TIMEOUT, dtmftimeout, option_verbose, RTCP_MAX_INTERVALMS, RTCP_MIN_INTERVALMS, rtcpinterval, rtpend, rtpstart, s, and VERBOSE_PREFIX_2. Referenced by ast_rtp_init(). { struct ast_config *cfg; const char *s; rtpstart = 5000; rtpend = 31000; dtmftimeout = DEFAULT_DTMF_TIMEOUT; cfg = ast_config_load("rtp.conf"); if (cfg) { if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) { rtpstart = atoi(s); if (rtpstart < 1024) rtpstart = 1024; if (rtpstart > 65535) rtpstart = 65535; } if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) { rtpend = atoi(s); if (rtpend < 1024) rtpend = 1024; if (rtpend > 65535) rtpend = 65535; } if ((s = ast_variable_retrieve(cfg, "general", "rtcpinterval"))) { rtcpinterval = atoi(s); if (rtcpinterval == 0) rtcpinterval = 0; /* Just so we're clear... it's zero */ if (rtcpinterval < RTCP_MIN_INTERVALMS) rtcpinterval = RTCP_MIN_INTERVALMS; /* This catches negative numbers too */ if (rtcpinterval > RTCP_MAX_INTERVALMS) rtcpinterval = RTCP_MAX_INTERVALMS; } if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) { #ifdef SO_NO_CHECK if (ast_false(s)) nochecksums = 1; else nochecksums = 0; #else if (ast_false(s)) ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n"); #endif } if ((s = ast_variable_retrieve(cfg, "general", "dtmftimeout"))) { dtmftimeout = atoi(s); if ((dtmftimeout < 0) || (dtmftimeout > 20000)) { ast_log(LOG_WARNING, "DTMF timeout of '%d' outside range, using default of '%d' instead\n", dtmftimeout, DEFAULT_DTMF_TIMEOUT); dtmftimeout = DEFAULT_DTMF_TIMEOUT; }; } ast_config_destroy(cfg); } if (rtpstart >= rtpend) { ast_log(LOG_WARNING, "Unreasonable values for RTP start/end port in rtp.conf\n"); rtpstart = 5000; rtpend = 31000; } if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend); return 0; }

void ast_rtp_reset (  struct ast_rtp *  rtp  )

Definition at line 2073 of file rtp.c. References ast_rtp::dtmfcount, ast_rtp::dtmfmute, ast_rtp::dtmfsamples, ast_rtp::lastdigitts, ast_rtp::lasteventendseqn, ast_rtp::lasteventseqn, ast_rtp::lastividtimestamp, ast_rtp::lastovidtimestamp, ast_rtp::lastrxformat, ast_rtp::lastrxts, ast_rtp::lastts, ast_rtp::lasttxformat, ast_rtp::rxcore, ast_rtp::rxseqno, ast_rtp::seqno, and ast_rtp::txcore. { memset(&rtp->rxcore, 0, sizeof(rtp->rxcore)); memset(&rtp->txcore, 0, sizeof(rtp->txcore)); memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute)); rtp->lastts = 0; rtp->lastdigitts = 0; rtp->lastrxts = 0; rtp->lastividtimestamp = 0; rtp->lastovidtimestamp = 0; rtp->lasteventseqn = 0; rtp->lasteventendseqn = 0; rtp->lasttxformat = 0; rtp->lastrxformat = 0; rtp->dtmfcount = 0; rtp->dtmfsamples = 0; rtp->seqno = 0; rtp->rxseqno = 0; }

int ast_rtp_sendcng (  struct ast_rtp *  rtp, int  level )

generate comfort noice (CNG) Definition at line 2568 of file rtp.c. References ast_inet_ntoa(), ast_log(), AST_RTP_CN, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::data, ast_rtp::dtmfmute, ast_rtp::lastts, LOG_ERROR, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by check_rtp_timeout(). { unsigned int *rtpheader; int hdrlen = 12; int res; int payload; char data[256]; level = 127 - (level & 0x7f); payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN); /* If we have no peer, return immediately */ if (!rtp->them.sin_addr.s_addr) return 0; rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); /* Get a pointer to the header */ rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++)); rtpheader[1] = htonl(rtp->lastts); rtpheader[2] = htonl(rtp->ssrc); data[12] = level; if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) { res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them)); if (res <0) 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)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent Comfort Noise RTP packet to %s:%u (type %d, seq %u, ts %u, len %d)\n" , ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen); } return 0; }

int ast_rtp_senddigit_begin (  struct ast_rtp *  rtp, char  digit )

Send begin frames for DTMF. Definition at line 2171 of file rtp.c. References ast_inet_ntoa(), ast_log(), AST_RTP_DTMF, ast_rtp_lookup_code(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastdigitts, LOG_ERROR, LOG_WARNING, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::send_duration, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by oh323_digit_begin(), and sip_senddigit_begin(). { unsigned int *rtpheader; int hdrlen = 12, res = 0, i = 0, payload = 0; char data[256]; if ((digit <= '9') && (digit >= '0')) digit -= '0'; else if (digit == '*') digit = 10; else if (digit == '#') digit = 11; else if ((digit >= 'A') && (digit <= 'D')) digit = digit - 'A' + 12; else if ((digit >= 'a') && (digit <= 'd')) digit = digit - 'a' + 12; else { ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit); return 0; } /* If we have no peer, return immediately */ if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return 0; payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF); rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); rtp->send_duration = 160; /* Get a pointer to the header */ rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno)); rtpheader[1] = htonl(rtp->lastdigitts); rtpheader[2] = htonl(rtp->ssrc); for (i = 0; i < 2; i++) { rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration)); res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them)); if (res < 0) ast_log(LOG_ERROR, "RTP Transmission error to %s:%u: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen); /* Increment sequence number */ rtp->seqno++; /* Increment duration */ rtp->send_duration += 160; /* Clear marker bit and set seqno */ rtpheader[0] = htonl((2 << 30) | (payload << 16) | (rtp->seqno)); } /* Since we received a begin, we can safely store the digit and disable any compensation */ rtp->sending_digit = 1; rtp->send_digit = digit; rtp->send_payload = payload; return 0; }

static int ast_rtp_senddigit_continuation (  struct ast_rtp *  rtp  )  [static]

Send continuation frame for DTMF. Definition at line 2235 of file rtp.c. References ast_inet_ntoa(), ast_log(), ast_verbose(), ast_rtp::lastdigitts, LOG_ERROR, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::send_digit, ast_rtp::send_duration, ast_rtp::send_payload, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by ast_rtp_read(). { unsigned int *rtpheader; int hdrlen = 12, res = 0; char data[256]; if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return 0; /* Setup packet to send */ rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno)); rtpheader[1] = htonl(rtp->lastdigitts); rtpheader[2] = htonl(rtp->ssrc); rtpheader[3] = htonl((rtp->send_digit << 24) | (0xa << 16) | (rtp->send_duration)); rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno)); /* Transmit */ res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them)); if (res < 0) ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen); /* Increment sequence number */ rtp->seqno++; /* Increment duration */ rtp->send_duration += 160; return 0; }

int ast_rtp_senddigit_end (  struct ast_rtp *  rtp, char  digit )

Send end packets for DTMF. Definition at line 2272 of file rtp.c. References ast_inet_ntoa(), ast_log(), ast_tvadd(), ast_verbose(), ast_rtp::dtmfmute, ast_rtp::lastdigitts, LOG_ERROR, LOG_WARNING, rtp_debug_test_addr(), ast_rtp::s, ast_rtp::send_duration, ast_rtp::send_payload, ast_rtp::seqno, ast_rtp::ssrc, and ast_rtp::them. Referenced by oh323_digit_end(), and sip_senddigit_end(). { unsigned int *rtpheader; int hdrlen = 12, res = 0, i = 0; char data[256]; /* If no address, then bail out */ if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port) return 0; if ((digit <= '9') && (digit >= '0')) digit -= '0'; else if (digit == '*') digit = 10; else if (digit == '#') digit = 11; else if ((digit >= 'A') && (digit <= 'D')) digit = digit - 'A' + 12; else if ((digit >= 'a') && (digit <= 'd')) digit = digit - 'a' + 12; else { ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit); return 0; } rtp->dtmfmute = ast_tvadd(ast_tvnow(), ast_tv(0, 500000)); rtpheader = (unsigned int *)data; rtpheader[0] = htonl((2 << 30) | (1 << 23) | (rtp->send_payload << 16) | (rtp->seqno)); rtpheader[1] = htonl(rtp->lastdigitts); rtpheader[2] = htonl(rtp->ssrc); rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (rtp->send_duration)); /* Set end bit */ rtpheader[3] |= htonl((1 << 23)); rtpheader[0] = htonl((2 << 30) | (rtp->send_payload << 16) | (rtp->seqno)); /* Send 3 termination packets */ for (i = 0; i < 3; i++) { res = sendto(rtp->s, (void *) rtpheader, hdrlen + 4, 0, (struct sockaddr *) &rtp->them, sizeof(rtp->them)); if (res < 0) ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno)); if (rtp_debug_test_addr(&rtp->them)) ast_verbose("Sent RTP DTMF packet to %s:%u (type %-2.2d, seq %-6.6u, ts %-6.6u, len %-6.6u)\n", ast_inet_ntoa(rtp->them.sin_addr), ntohs(rtp->them.sin_port), rtp->send_payload, rtp->seqno, rtp->lastdigitts, res - hdrlen); } rtp->sending_digit = 0; rtp->send_digit = 0; /* Increment lastdigitts */ rtp->lastdigitts += 960; rtp->seqno++; return res; }

void ast_rtp_set_callback (  struct ast_rtp *  rtp, ast_rtp_callback  callback )

Definition at line 587 of file rtp.c. References ast_rtp::callback. Referenced by start_rtp(). { rtp->callback = callback; }

void ast_rtp_set_data (  struct ast_rtp *  rtp, void *  data )

Definition at line 582 of file rtp.c. References ast_rtp::data. Referenced by start_rtp(). { rtp->data = data; }

void ast_rtp_set_m_type (  struct ast_rtp *  rtp, int  pt )

Make a note of a RTP payload type that was seen in a SDP "m=" line. By default, use the well-known value for this type (although it may still be set to a different value by a subsequent "a=rtpmap:" line). Definition at line 1668 of file rtp.c. References ast_rtp::current_RTP_PT, MAX_RTP_PT, rtp_bridge_lock(), rtp_bridge_unlock(), and static_RTP_PT. Referenced by gtalk_newcall(), jingle_newcall(), and process_sdp(). { if (pt < 0 || pt > MAX_RTP_PT || static_RTP_PT[pt].code == 0) return; /* bogus payload type */ rtp_bridge_lock(rtp); rtp->current_RTP_PT[pt] = static_RTP_PT[pt]; rtp_bridge_unlock(rtp); }

void ast_rtp_set_peer (  struct ast_rtp *  rtp, struct sockaddr_in *  them )

Definition at line 2016 of file rtp.c. References ast_rtp::rtcp, ast_rtp::rxseqno, ast_rtp::them, and ast_rtcp::them. Referenced by handle_open_receive_channel_ack_message(), process_sdp(), and setup_rtp_connection(). { rtp->them.sin_port = them->sin_port; rtp->them.sin_addr = them->sin_addr; if (rtp->rtcp) { rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1); rtp->rtcp->them.sin_addr = them->sin_addr; } rtp->rxseqno = 0; }

void ast_rtp_set_rtpholdtimeout (  struct ast_rtp *  rtp, int  timeout )

Set rtp hold timeout. Definition at line 549 of file rtp.c. References ast_rtp::rtpholdtimeout. Referenced by check_rtp_timeout(), create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtpholdtimeout = timeout; }

void ast_rtp_set_rtpkeepalive (  struct ast_rtp *  rtp, int  period )

set RTP keepalive interval Definition at line 555 of file rtp.c. References ast_rtp::rtpkeepalive. Referenced by create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtpkeepalive = period; }

void ast_rtp_set_rtpmap_type (  struct ast_rtp *  rtp, int  pt, char *  mimeType, char *  mimeSubtype, enum ast_rtp_options  options )

Make a note of a RTP payload type (with MIME type) that was seen in an SDP "a=rtpmap:" line. Definition at line 1681 of file rtp.c. References AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_RTP_OPT_G726_NONSTANDARD, rtpPayloadType::code, ast_rtp::current_RTP_PT, MAX_RTP_PT, mimeTypes, payloadType, rtp_bridge_lock(), subtype, and type. Referenced by __oh323_rtp_create(), gtalk_newcall(), jingle_newcall(), process_sdp(), set_dtmf_payload(), and setup_rtp_connection(). { unsigned int i; if (pt < 0 || pt > MAX_RTP_PT) return; /* bogus payload type */ rtp_bridge_lock(rtp); for (i = 0; i < sizeof(mimeTypes)/sizeof(mimeTypes[0]); ++i) { if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 && strcasecmp(mimeType, mimeTypes[i].type) == 0) { rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType; if ((mimeTypes[i].payloadType.code == AST_FORMAT_G726) && mimeTypes[i].payloadType.isAstFormat && (options & AST_RTP_OPT_G726_NONSTANDARD)) rtp->current_RTP_PT[pt].code = AST_FORMAT_G726_AAL2; break; } } rtp_bridge_unlock(rtp); return; }

void ast_rtp_set_rtptimeout (  struct ast_rtp *  rtp, int  timeout )

Set rtp timeout. Definition at line 543 of file rtp.c. References ast_rtp::rtptimeout. Referenced by check_rtp_timeout(), create_addr_from_peer(), dialog_activate_media(), and sip_alloc(). { rtp->rtptimeout = timeout; }

void ast_rtp_set_rtptimers_onhold (  struct ast_rtp *  rtp  )

Definition at line 536 of file rtp.c. References ast_rtp::rtpholdtimeout, and ast_rtp::rtptimeout. Referenced by handle_response_answer(), and handle_response_invite(). { rtp->rtptimeout = (-1) * rtp->rtptimeout; rtp->rtpholdtimeout = (-1) * rtp->rtpholdtimeout; }

void ast_rtp_setdtmf (  struct ast_rtp *  rtp, int  dtmf )

Indicate whether this RTP session is carrying DTMF or not. Definition at line 602 of file rtp.c. References ast_set2_flag, and FLAG_HAS_DTMF. Referenced by create_addr_from_peer(), dialog_activate_media(), handle_request_invite(), and sip_alloc(). { ast_set2_flag(rtp, dtmf ? 1 : 0, FLAG_HAS_DTMF); }

void ast_rtp_setdtmfcompensate (  struct ast_rtp *  rtp, int  compensate )

Compensate for devices that send RFC2833 packets all at once. Definition at line 607 of file rtp.c. References ast_set2_flag, and FLAG_DTMF_COMPENSATE. Referenced by create_addr_from_peer(), dialog_activate_media(), handle_request_invite(), and sip_alloc(). { ast_set2_flag(rtp, compensate ? 1 : 0, FLAG_DTMF_COMPENSATE); }

void ast_rtp_setnat (  struct ast_rtp *  rtp, int  nat )

Definition at line 592 of file rtp.c. References ast_rtp::nat. Referenced by __oh323_rtp_create(), do_setnat(), oh323_rtp_read(), and start_rtp(). { rtp->nat = nat; }

void ast_rtp_setstun (  struct ast_rtp *  rtp, int  stun_enable )

Enable STUN capability. Definition at line 612 of file rtp.c. References ast_set2_flag, and FLAG_HAS_STUN. Referenced by gtalk_new(). { ast_set2_flag(rtp, stun_enable ? 1 : 0, FLAG_HAS_STUN); }

int ast_rtp_settos (  struct ast_rtp *  rtp, int  tos )

Definition at line 2007 of file rtp.c. References ast_log(), LOG_WARNING, and ast_rtp::s. Referenced by __oh323_rtp_create(), dialog_activate_media(), and sip_alloc(). { int res; if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos); return res; }

void ast_rtp_stop (  struct ast_rtp *  rtp  )

Stop RTP session, do not destroy structure Definition at line 2056 of file rtp.c. References ast_clear_flag, ast_sched_del(), FLAG_P2P_SENT_MARK, ast_rtp::rtcp, ast_rtp::sched, ast_rtcp::schedid, ast_rtp::them, and ast_rtcp::them. Referenced by setup_rtp_connection(), and stop_media_flows(). { if (rtp->rtcp && rtp->rtcp->schedid > 0) { ast_sched_del(rtp->sched, rtp->rtcp->schedid); rtp->rtcp->schedid = -1; } memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr)); memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port)); if (rtp->rtcp) { memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->rtcp->them.sin_addr)); memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->rtcp->them.sin_port)); } ast_clear_flag(rtp, FLAG_P2P_SENT_MARK); }

void ast_rtp_stun_request (  struct ast_rtp *  rtp, struct sockaddr_in *  suggestion, const char *  username )

Send STUN request (??). Definition at line 404 of file rtp.c. References append_attr_string(), stun_attr::attr, ast_rtp::s, STUN_BINDREQ, stun_req_id(), stun_send(), and STUN_USERNAME. Referenced by gtalk_update_stun(), and jingle_update_stun(). { struct stun_header *req; unsigned char reqdata[1024]; int reqlen, reqleft; struct stun_attr *attr; req = (struct stun_header *)reqdata; stun_req_id(req); reqlen = 0; reqleft = sizeof(reqdata) - sizeof(struct stun_header); req->msgtype = 0; req->msglen = 0; attr = (struct stun_attr *)req->ies; if (username) append_attr_string(&attr, STUN_USERNAME, username, &reqlen, &reqleft); req->msglen = htons(reqlen); req->msgtype = htons(STUN_BINDREQ); stun_send(rtp->s, suggestion, req); }

int ast_rtp_write (  struct ast_rtp *  rtp, struct ast_frame *  _f )

Bug: XXX this might never be free'd. Why do we do this? Definition at line 2722 of file rtp.c. References ast_codec_pref_getsize(), AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_getformatname(),