switch_rtp.c File Reference

#include <switch.h>
#include <switch_private.h>
#include <switch_stun.h>
#include <apr_network_io.h>
#include <datatypes.h>
#include <srtp.h>
#include <srtp_priv.h>
#include <switch_ssl.h>
#include <switch_jitterbuffer.h>

Include dependency graph for switch_rtp.c:

Go to the source code of this file.

Data Structures
struct	rtp_msg_t
struct	rtcp_fir_t
struct	switch_rtcp_sdes_unit_s
struct	rtcp_tmmbx_t
struct	switch_rtcp_ext_hdr_t
struct	rtcp_ext_msg_t
struct	rtcp_msg_t
struct	switch_rtp_vad_data
struct	switch_rtp_rfc2833_data
struct	switch_rtp_ice_t
struct	switch_dtls_s
struct	ts_normalize_s
struct	switch_rtp
struct	switch_rtcp_report_block
struct	switch_rtcp_sr_head
struct	switch_rtcp_sender_info
struct	switch_rtcp_sender_report
struct	switch_rtcp_receiver_report

Macros
#define	JITTER_LEAD_FRAMES   10
#define	READ_INC(rtp_session)   switch_mutex_lock(rtp_session->read_mutex); rtp_session->reading++
#define	READ_DEC(rtp_session)   switch_mutex_unlock(rtp_session->read_mutex); rtp_session->reading--
#define	WRITE_INC(rtp_session)   switch_mutex_lock(rtp_session->write_mutex); rtp_session->writing++
#define	WRITE_DEC(rtp_session)   switch_mutex_unlock(rtp_session->write_mutex); rtp_session->writing--
#define	RTP_STUN_FREQ   1000000
#define	rtp_header_len   12
#define	RTP_START_PORT   16384
#define	RTP_END_PORT   32768
#define	MASTER_KEY_LEN   30
#define	RTP_MAGIC_NUMBER   42
#define	WARN_SRTP_ERRS   10
#define	MAX_SRTP_ERRS   100
#define	NTP_TIME_OFFSET   2208988800UL
#define	ZRTP_MAGIC_COOKIE   0x5a525450
#define	DTMF_SANITY   (rtp_session->one_second * 30)
#define	rtp_session_name(_rtp_session)   _rtp_session->session ? switch_core_session_get_name(_rtp_session->session) : "-"
#define	RTP_BODY(_s)   (char *) (_s->recv_msg.ebody ? _s->recv_msg.ebody : _s->recv_msg.body)
#define	rtp_type(rtp_session)   rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"
#define	MAX_NACK   10
#define	dtls_set_state(_dtls, _state)   switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n", rtp_type(rtp_session), dtls_state_names(_dtls->state), dtls_state_names(_state)); _dtls->new_state = 1; _dtls->last_state = _dtls->state; _dtls->state = _state
#define	cr_keylen   16
#define	cr_saltlen   14
#define	cr_kslen   30
#define	return_cng_frame()   do_cng = 1; goto timer_check

Typedefs
typedef srtp_hdr_t	rtp_hdr_t
typedef struct switch_rtcp_sdes_unit_s	switch_rtcp_sdes_unit_t
typedef struct switch_dtls_s	switch_dtls_t
typedef int(*	dtls_state_handler_t )(switch_rtp_t *, switch_dtls_t *)
typedef struct ts_normalize_s	ts_normalize_t

Enumerations
enum	vad_talk_mask_t { VAD_FIRE_TALK = (1 << 0), VAD_FIRE_NOT_TALK = (1 << 1) }
enum	handle_rfc2833_result_t { RESULT_CONTINUE, RESULT_GOTO_END, RESULT_GOTO_RECVFROM, RESULT_GOTO_TIMERCHECK }

Functions
static switch_size_t	do_flush (switch_rtp_t *rtp_session, int force, switch_size_t bytes_in)
static int	dtls_state_handshake (switch_rtp_t *rtp_session, switch_dtls_t *dtls)
static int	dtls_state_ready (switch_rtp_t *rtp_session, switch_dtls_t *dtls)
static int	dtls_state_setup (switch_rtp_t *rtp_session, switch_dtls_t *dtls)
static int	dtls_state_fail (switch_rtp_t *rtp_session, switch_dtls_t *dtls)
static void	do_2833 (switch_rtp_t *rtp_session)
static void	switch_rtp_change_ice_dest (switch_rtp_t *rtp_session, switch_rtp_ice_t *ice, const char *host, switch_port_t port)
static handle_rfc2833_result_t	handle_rfc2833 (switch_rtp_t *rtp_session, switch_size_t bytes, int *do_cng)
static int	rtp_write_ready (switch_rtp_t *rtp_session, uint32_t bytes, int line)
static int	rtp_common_write (switch_rtp_t *rtp_session, rtp_msg_t *send_msg, void *data, uint32_t datalen, switch_payload_t payload, uint32_t timestamp, switch_frame_flag_t *flags)
static switch_status_t	ice_out (switch_rtp_t *rtp_session, switch_rtp_ice_t *ice)
int	icecmp (const char *them, switch_rtp_ice_t *ice)
static void	handle_ice (switch_rtp_t *rtp_session, switch_rtp_ice_t *ice, void *data, switch_size_t len)
void	switch_rtp_init (switch_memory_pool_t *pool)
	Initilize the RTP System. More...
static uint8_t	get_next_write_ts (switch_rtp_t *rtp_session, uint32_t timestamp)
static void	do_mos (switch_rtp_t *rtp_session, int force)
void	burstr_calculate (int loss[], int received, double *burstr, double *lossr)
static void	reset_jitter_seq (switch_rtp_t *rtp_session)
static void	check_jitter (switch_rtp_t *rtp_session)
static void	rtcp_generate_sender_info (switch_rtp_t *rtp_session, struct switch_rtcp_sender_info *sr)
static void	rtcp_generate_report_block (switch_rtp_t *rtp_session, struct switch_rtcp_report_block *rtcp_report_block)
static void	rtcp_stats_init (switch_rtp_t *rtp_session)
static int	rtcp_stats (switch_rtp_t *rtp_session)
static void	calc_bw_exp (uint32_t bps, uint8_t bits, rtcp_tmmbx_t *tmmbx)
static int	using_ice (switch_rtp_t *rtp_session)
static int	check_rtcp_and_ice (switch_rtp_t *rtp_session)
void	switch_rtp_ping (switch_rtp_t *rtp_session)
void	switch_rtp_get_random (void *buf, uint32_t len)
void	switch_rtp_shutdown (void)
switch_port_t	switch_rtp_set_start_port (switch_port_t port)
	Set/Get RTP start port. More...
switch_port_t	switch_rtp_set_end_port (switch_port_t port)
	Set/Get RTP end port. More...
void	switch_rtp_release_port (const char *ip, switch_port_t port)
switch_port_t	switch_rtp_request_port (const char *ip)
	Request a new port to be used for media. More...
switch_status_t	switch_rtp_set_payload_map (switch_rtp_t *rtp_session, payload_map_t **pmap)
void	switch_rtp_intentional_bugs (switch_rtp_t *rtp_session, switch_rtp_bug_flag_t bugs)
static switch_status_t	enable_remote_rtcp_socket (switch_rtp_t *rtp_session, const char **err)
static switch_status_t	enable_local_rtcp_socket (switch_rtp_t *rtp_session, const char **err)
switch_status_t	switch_rtp_set_local_address (switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
	Assign a local address to the RTP session. More...
void	switch_rtp_set_max_missed_packets (switch_rtp_t *rtp_session, uint32_t max)
void	switch_rtp_reset_jb (switch_rtp_t *rtp_session)
void	switch_rtp_reset_vb (switch_rtp_t *rtp_session)
void	switch_rtp_reset (switch_rtp_t *rtp_session)
void	switch_rtp_reset_media_timer (switch_rtp_t *rtp_session)
char *	switch_rtp_get_remote_host (switch_rtp_t *rtp_session)
switch_port_t	switch_rtp_get_remote_port (switch_rtp_t *rtp_session)
static void	ping_socket (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_udptl_mode (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_set_remote_address (switch_rtp_t *rtp_session, const char *host, switch_port_t port, switch_port_t remote_rtcp_port, switch_bool_t change_adv_addr, const char **err)
	Assign a remote address to the RTP session. More...
static const char *	dtls_state_names (dtls_state_t s)
static void	free_dtls (switch_dtls_t **dtlsp)
static int	do_dtls (switch_rtp_t *rtp_session, switch_dtls_t *dtls)
int	switch_rtp_has_dtls (void)
dtls_state_t	switch_rtp_dtls_state (switch_rtp_t *rtp_session, dtls_type_t type)
switch_status_t	switch_rtp_del_dtls (switch_rtp_t *rtp_session, dtls_type_t type)
switch_status_t	switch_rtp_add_dtls (switch_rtp_t *rtp_session, dtls_fingerprint_t *local_fp, dtls_fingerprint_t *remote_fp, dtls_type_t type)
switch_status_t	switch_rtp_add_crypto_key (switch_rtp_t *rtp_session, switch_rtp_crypto_direction_t direction, uint32_t index, switch_rtp_crypto_key_type_t type, unsigned char *key, switch_size_t keylen)
switch_status_t	switch_rtp_set_interval (switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
switch_status_t	switch_rtp_change_interval (switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
switch_status_t	switch_rtp_set_ssrc (switch_rtp_t *rtp_session, uint32_t ssrc)
switch_status_t	switch_rtp_set_remote_ssrc (switch_rtp_t *rtp_session, uint32_t ssrc)
switch_status_t	switch_rtp_create (switch_rtp_t **new_rtp_session, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID], char *timer_name, const char **err, switch_memory_pool_t *pool)
switch_rtp_t *	switch_rtp_new (const char *rx_host, switch_port_t rx_port, const char *tx_host, switch_port_t tx_port, switch_payload_t payload, uint32_t samples_per_interval, uint32_t ms_per_packet, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID], char *timer_name, const char **err, switch_memory_pool_t *pool)
void	switch_rtp_set_telephony_event (switch_rtp_t *rtp_session, switch_payload_t te)
	Set the payload type to consider RFC2833 DTMF. More...
void	switch_rtp_set_telephony_recv_event (switch_rtp_t *rtp_session, switch_payload_t te)
void	switch_rtp_set_cng_pt (switch_rtp_t *rtp_session, switch_payload_t pt)
	Set the payload type for comfort noise. More...
switch_timer_t *	switch_rtp_get_media_timer (switch_rtp_t *rtp_session)
switch_jb_t *	switch_rtp_get_jitter_buffer (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_pause_jitter_buffer (switch_rtp_t *rtp_session, switch_bool_t pause)
switch_status_t	switch_rtp_deactivate_jitter_buffer (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_get_video_buffer_size (switch_rtp_t *rtp_session, uint32_t *min_frame_len, uint32_t *max_frame_len, uint32_t *cur_frame_len, uint32_t *highest_frame_len)
switch_status_t	switch_rtp_set_video_buffer_size (switch_rtp_t *rtp_session, uint32_t frames, uint32_t max_frames)
switch_status_t	switch_rtp_debug_jitter_buffer (switch_rtp_t *rtp_session, const char *name)
switch_status_t	switch_rtp_activate_jitter_buffer (switch_rtp_t *rtp_session, uint32_t queue_frames, uint32_t max_queue_frames, uint32_t samples_per_packet, uint32_t samples_per_second)
	Acvite a jitter buffer on an RTP session. More...
switch_status_t	switch_rtp_activate_rtcp (switch_rtp_t *rtp_session, int send_rate, switch_port_t remote_port, switch_bool_t mux)
	Activate sending RTCP Sender Reports (SR's) More...
switch_status_t	switch_rtp_activate_ice (switch_rtp_t *rtp_session, char *login, char *rlogin, const char *password, const char *rpassword, ice_proto_t proto, switch_core_media_ice_type_t type, ice_t *ice_params)
	Acvite ICE on an RTP session. More...
void	switch_rtp_flush (switch_rtp_t *rtp_session)
switch_status_t	switch_rtp_req_bitrate (switch_rtp_t *rtp_session, uint32_t bps)
switch_status_t	switch_rtp_ack_bitrate (switch_rtp_t *rtp_session, uint32_t bps)
void	switch_rtp_video_refresh (switch_rtp_t *rtp_session)
void	switch_rtp_video_loss (switch_rtp_t *rtp_session)
void	switch_rtp_break (switch_rtp_t *rtp_session)
void	switch_rtp_kill_socket (switch_rtp_t *rtp_session)
	Kill the socket on an existing RTP session. More...
uint8_t	switch_rtp_ready (switch_rtp_t *rtp_session)
	Test if an RTP session is ready. More...
switch_status_t	switch_rtp_sync_stats (switch_rtp_t *rtp_session)
void	switch_rtp_destroy (switch_rtp_t **rtp_session)
	Destroy an RTP session. More...
void	switch_rtp_set_interdigit_delay (switch_rtp_t *rtp_session, uint32_t delay)
switch_socket_t *	switch_rtp_get_rtp_socket (switch_rtp_t *rtp_session)
	Retrieve the socket from an existing RTP session. More...
uint32_t	switch_rtp_get_default_samples_per_interval (switch_rtp_t *rtp_session)
	Get the default samples per interval for a given RTP session. More...
void	switch_rtp_set_default_payload (switch_rtp_t *rtp_session, switch_payload_t payload)
	Set the default payload number for a given RTP session. More...
uint32_t	switch_rtp_get_default_payload (switch_rtp_t *rtp_session)
	Get the default payload number for a given RTP session. More...
void	switch_rtp_set_invalid_handler (switch_rtp_t *rtp_session, switch_rtp_invalid_handler_t on_invalid)
	Set a callback function to execute when an invalid RTP packet is encountered. More...
void	switch_rtp_set_flags (switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
void	switch_rtp_clear_flags (switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
void	switch_rtp_set_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
	Set an RTP Flag. More...
uint32_t	switch_rtp_test_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
	Test an RTP Flag. More...
void	switch_rtp_clear_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
	Clear an RTP Flag. More...
static void	set_dtmf_delay (switch_rtp_t *rtp_session, uint32_t ms, uint32_t max_ms)
void	rtp_flush_read_buffer (switch_rtp_t *rtp_session, switch_rtp_flush_t flush)
static int	jb_valid (switch_rtp_t *rtp_session)
static int	check_recv_payload (switch_rtp_t *rtp_session)
static int	get_recv_payload (switch_rtp_t *rtp_session)
static switch_status_t	read_rtp_packet (switch_rtp_t *rtp_session, switch_size_t *bytes, switch_frame_flag_t *flags, switch_status_t poll_status, switch_bool_t return_jb_packet)
static void	handle_nack (switch_rtp_t *rtp_session, uint32_t nack)
static switch_status_t	process_rtcp_report (switch_rtp_t *rtp_session, rtcp_msg_t *msg, switch_size_t bytes)
static switch_status_t	process_rtcp_packet (switch_rtp_t *rtp_session, switch_size_t *bytes)
static switch_status_t	read_rtcp_packet (switch_rtp_t *rtp_session, switch_size_t *bytes, switch_frame_flag_t *flags)
static int	rtp_common_read (switch_rtp_t *rtp_session, switch_payload_t *payload_type, payload_map_t **pmapP, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
switch_byte_t	switch_rtp_check_auto_adj (switch_rtp_t *rtp_session)
switch_size_t	switch_rtp_has_dtmf (switch_rtp_t *rtp_session)
	Test for presence of DTMF on a given RTP session. More...
switch_size_t	switch_rtp_dequeue_dtmf (switch_rtp_t *rtp_session, switch_dtmf_t *dtmf)
	Retrieve DTMF digits from a given RTP session. More...
switch_status_t	switch_rtp_queue_rfc2833 (switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
	Queue RFC2833 DTMF data into an RTP Session. More...
switch_status_t	switch_rtp_queue_rfc2833_in (switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
	Queue RFC2833 DTMF data into an RTP Session. More...
switch_status_t	switch_rtp_read (switch_rtp_t *rtp_session, void *data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
	Read data from a given RTP session. More...
switch_status_t	switch_rtcp_zerocopy_read_frame (switch_rtp_t *rtp_session, switch_rtcp_frame_t *frame)
	Read RTCP data from a given RTP session without copying. More...
switch_status_t	switch_rtp_zerocopy_read_frame (switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flags)
	Read data from a given RTP session without copying. More...
switch_status_t	switch_rtp_zerocopy_read (switch_rtp_t *rtp_session, void **data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
	Read data from a given RTP session without copying. More...
switch_status_t	switch_rtp_disable_vad (switch_rtp_t *rtp_session)
	Disable VAD on an RTP Session. More...
switch_status_t	switch_rtp_enable_vad (switch_rtp_t *rtp_session, switch_core_session_t *session, switch_codec_t *codec, switch_vad_flag_t flags)
	Enable VAD on an RTP Session. More...
int	switch_rtp_write_frame (switch_rtp_t *rtp_session, switch_frame_t *frame)
	Write data to a given RTP session. More...
switch_rtp_stats_t *	switch_rtp_get_stats (switch_rtp_t *rtp_session, switch_memory_pool_t *pool)
int	switch_rtp_write_manual (switch_rtp_t *rtp_session, void *data, uint32_t datalen, uint8_t m, switch_payload_t payload, uint32_t ts, switch_frame_flag_t *flags)
	Write data with a specified payload and sequence number to a given RTP session. More...
switch_status_t	switch_rtp_write_raw (switch_rtp_t *rtp_session, void *data, switch_size_t *bytes, switch_bool_t process_encryption)
uint32_t	switch_rtp_get_ssrc (switch_rtp_t *rtp_session)
	Retrieve the SSRC from a given RTP session. More...
void	switch_rtp_set_private (switch_rtp_t *rtp_session, void *private_data)
	Associate an arbitrary data pointer with and RTP session. More...
void *	switch_rtp_get_private (switch_rtp_t *rtp_session)
	Retrieve the private data from a given RTP session. More...

Variables
static const switch_payload_t	INVALID_PT = 255
static switch_port_t	START_PORT = RTP_START_PORT
static switch_port_t	END_PORT = RTP_END_PORT
static switch_mutex_t *	port_lock = NULL
static switch_hash_t *	alloc_hash = NULL
dtls_state_handler_t	dtls_states [DS_INVALID] = {NULL, dtls_state_handshake, dtls_state_setup, dtls_state_ready, dtls_state_fail}
static int	global_init = 0
static const char *	dtls_state_names_t [] = {"OFF", "HANDSHAKE", "SETUP", "READY", "FAIL", "INVALID"}

Macro Definition Documentation

#define cr_keylen   16

Definition at line 3001 of file switch_rtp.c.

Referenced by dtls_state_setup().

#define cr_kslen   30

Definition at line 3003 of file switch_rtp.c.

Referenced by dtls_state_setup().

#define cr_saltlen   14

Definition at line 3002 of file switch_rtp.c.

Referenced by dtls_state_setup().

#define dtls_set_state	(		_dtls,
			_state
	)		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n", rtp_type(rtp_session), dtls_state_names(_dtls->state), dtls_state_names(_state)); _dtls->new_state = 1; _dtls->last_state = _dtls->state; _dtls->state = _state

Definition at line 2999 of file switch_rtp.c.

Referenced by dtls_state_handshake(), dtls_state_setup(), and switch_rtp_add_dtls().

#define DTMF_SANITY   (rtp_session->one_second * 30)

Definition at line 77 of file switch_rtp.c.

Referenced by handle_rfc2833().

#define JITTER_LEAD_FRAMES   10

Definition at line 59 of file switch_rtp.c.

Referenced by check_jitter(), and rtp_common_read().

#define MASTER_KEY_LEN   30

Definition at line 69 of file switch_rtp.c.

#define MAX_NACK   10

Definition at line 1955 of file switch_rtp.c.

Referenced by check_rtcp_and_ice().

#define MAX_SRTP_ERRS   100

Definition at line 72 of file switch_rtp.c.

Referenced by read_rtp_packet().

#define NTP_TIME_OFFSET   2208988800UL

Definition at line 73 of file switch_rtp.c.

Referenced by process_rtcp_report(), rtcp_generate_report_block(), and rtcp_generate_sender_info().

#define READ_DEC

(

rtp_session

)

switch_mutex_unlock(rtp_session->read_mutex); rtp_session->reading--

Definition at line 61 of file switch_rtp.c.

Referenced by do_flush(), handle_ice(), ice_out(), rtp_common_read(), switch_rtp_activate_jitter_buffer(), switch_rtp_change_interval(), switch_rtp_destroy(), switch_rtp_set_local_address(), and switch_rtp_udptl_mode().

#define READ_INC

(

rtp_session

)

switch_mutex_lock(rtp_session->read_mutex); rtp_session->reading++

Definition at line 60 of file switch_rtp.c.

Referenced by do_flush(), handle_ice(), ice_out(), rtp_common_read(), switch_rtp_activate_jitter_buffer(), switch_rtp_change_interval(), switch_rtp_destroy(), switch_rtp_set_local_address(), and switch_rtp_udptl_mode().

#define return_cng_frame

(

)

do_cng = 1; goto timer_check

Definition at line 5131 of file switch_rtp.c.

Referenced by rtp_common_read().

#define RTP_BODY

(

_s

)

(char *) (_s->recv_msg.ebody ? _s->recv_msg.ebody : _s->recv_msg.body)

Definition at line 118 of file switch_rtp.c.

Referenced by handle_rfc2833(), read_rtp_packet(), rtp_common_read(), switch_rtp_read(), switch_rtp_zerocopy_read(), and switch_rtp_zerocopy_read_frame().

#define RTP_END_PORT   32768

Definition at line 68 of file switch_rtp.c.

#define rtp_header_len   12

Definition at line 66 of file switch_rtp.c.

Referenced by do_flush(), handle_rfc2833(), read_rtp_packet(), rtp_common_read(), rtp_common_write(), switch_rtp_read(), switch_rtp_write_manual(), switch_rtp_zerocopy_read(), and switch_rtp_zerocopy_read_frame().

#define RTP_MAGIC_NUMBER   42

Definition at line 70 of file switch_rtp.c.

#define rtp_session_name

(

_rtp_session

)

_rtp_session->session ? switch_core_session_get_name(_rtp_session->session) : "-"

Definition at line 79 of file switch_rtp.c.

Referenced by check_jitter(), check_rtcp_and_ice(), do_mos(), handle_ice(), ice_out(), and rtp_common_read().

#define RTP_START_PORT   16384

Definition at line 67 of file switch_rtp.c.

#define RTP_STUN_FREQ   1000000

Definition at line 65 of file switch_rtp.c.

Referenced by ice_out().

#define rtp_type

(

rtp_session

)

rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"

Definition at line 513 of file switch_rtp.c.

Referenced by check_jitter(), check_rtcp_and_ice(), do_dtls(), do_mos(), dtls_state_handshake(), dtls_state_setup(), handle_ice(), ice_out(), read_rtp_packet(), rtcp_stats_init(), rtp_common_read(), rtp_common_write(), rtp_write_ready(), switch_rtp_activate_ice(), and switch_rtp_add_dtls().

#define WARN_SRTP_ERRS   10

Definition at line 71 of file switch_rtp.c.

Referenced by read_rtp_packet().

#define WRITE_DEC

(

rtp_session

)

switch_mutex_unlock(rtp_session->write_mutex); rtp_session->writing--

Definition at line 63 of file switch_rtp.c.

Referenced by handle_ice(), rtp_common_write(), switch_rtp_change_interval(), switch_rtp_destroy(), switch_rtp_set_local_address(), switch_rtp_udptl_mode(), switch_rtp_write_manual(), and switch_rtp_write_raw().

#define WRITE_INC

(

rtp_session

)

switch_mutex_lock(rtp_session->write_mutex); rtp_session->writing++

Definition at line 62 of file switch_rtp.c.

Referenced by handle_ice(), rtp_common_write(), switch_rtp_change_interval(), switch_rtp_destroy(), switch_rtp_set_local_address(), switch_rtp_udptl_mode(), switch_rtp_write_manual(), and switch_rtp_write_raw().

#define ZRTP_MAGIC_COOKIE   0x5a525450

Definition at line 74 of file switch_rtp.c.

Referenced by read_rtp_packet().

Typedef Documentation

typedef int(* dtls_state_handler_t)(switch_rtp_t *, switch_dtls_t *)

Definition at line 283 of file switch_rtp.c.

typedef srtp_hdr_t rtp_hdr_t

Definition at line 86 of file switch_rtp.c.

typedef struct switch_dtls_s switch_dtls_t

typedef struct switch_rtcp_sdes_unit_s switch_rtcp_sdes_unit_t

typedef struct ts_normalize_s ts_normalize_t

Enumeration Type Documentation

enum handle_rfc2833_result_t

Enumerator
RESULT_CONTINUE
RESULT_GOTO_END
RESULT_GOTO_RECVFROM
RESULT_GOTO_TIMERCHECK

Definition at line 503 of file switch_rtp.c.

             {
        RESULT_CONTINUE,
        RESULT_GOTO_END,
        RESULT_GOTO_RECVFROM,
        RESULT_GOTO_TIMERCHECK
} handle_rfc2833_result_t;

enum vad_talk_mask_t

Enumerator
VAD_FIRE_TALK
VAD_FIRE_NOT_TALK

Definition at line 185 of file switch_rtp.c.

             {
        VAD_FIRE_TALK = (1 << 0),
        VAD_FIRE_NOT_TALK = (1 << 1)
} vad_talk_mask_t;

Function Documentation

void burstr_calculate	(	int	loss[],
		int	received,
		double *	burstr,
		double *	lossr
	)

Definition at line 1570 of file switch_rtp.c.

References switch_rtcp_report_block::lost, and LOST_BURST_ANALYZE.

Referenced by check_jitter().

{
        int lost = 0;
        int bursts = 0;
        int i;

        for ( i = 0; i < LOST_BURST_ANALYZE; i++ ) {
                lost += i * loss[i];
                bursts += loss[i];
        }
        if (received > 0 && bursts > 0) {
                *burstr = (double)((double)lost / (double)bursts) / (double)(1.0 / ( 1.0 - (double)lost / (double)received ));
                if (*burstr < 0) {
                        *burstr = - *burstr;
                }
        } else {
                *burstr = 0;
        }
        if (received > 0) {
                *lossr = (double)((double)lost / (double)received);
        } else {
                *lossr = 0;
        }
}

static void calc_bw_exp ( uint32_t  bps, uint8_t  bits, rtcp_tmmbx_t *  tmmbx  )

static

Definition at line 1920 of file switch_rtp.c.

References rtcp_tmmbx_t::parts, and switch_assert.

Referenced by check_rtcp_and_ice().

{
        uint32_t mantissa_max, i = 0;
        uint8_t exp = 0;
        uint32_t mantissa = 0;
        uint16_t overhead = 60;

        switch_assert(bits<=32);

        mantissa_max = (1 << bits) - 1;

        for (i = 0; i < 32; ++i) {
                if (bps <= (mantissa_max << i)) {
                        exp = i;
                        break;
                }
        }
        
        mantissa = (bps >> exp);

        tmmbx->parts[0] = (uint8_t) ((exp << 2) + ((mantissa >> 15) & 0x03));
        tmmbx->parts[1] = (uint8_t) (mantissa >> 7);
        tmmbx->parts[2] = (uint8_t) ((mantissa >> 1) + ((overhead >> 8) & 0x01));
        tmmbx->parts[3] = (uint8_t) (overhead);
}

static void check_jitter ( switch_rtp_t *  rtp_session )

static

Definition at line 1604 of file switch_rtp.c.

References switch_rtp::bad_stream, burstr_calculate(), switch_rtp_numbers_t::burstrate, switch_rtp::clean_stream, do_mos(), switch_rtp::dtmf_data, switch_rtp_numbers_t::error_log, switch_rtp::flags, switch_rtp_numbers_t::flaws, switch_rtp_rfc2833_data::in_digit_ts, switch_rtp_stats_t::inbound, IPDV_THRESHOLD, switch_rtp_numbers_t::jitter_add, switch_rtp_numbers_t::jitter_addsq, switch_rtp::jitter_lead, JITTER_LEAD_FRAMES, switch_rtp_numbers_t::jitter_n, switch_rtp_numbers_t::last_loss, switch_rtp_numbers_t::last_proc_time, switch_rtp_numbers_t::last_processed_seq, switch_rtp::last_rtp_hdr, switch_rtp_numbers_t::loss, switch_rtp_numbers_t::lossrate, switch_rtcp_report_block::lost, LOST_BURST_CAPTURE, switch_rtp_numbers_t::max_variance, switch_rtp_numbers_t::mean_interval, switch_rtp_numbers_t::min_variance, error_period::next, switch_rtp::next_stat_check_time, switch_rtp::old_mean, switch_rtp::one_second, switch_rtp::recovering_stream, switch_rtp_numbers_t::recved, reset_jitter_seq(), rtp_session_name, rtp_type, switch_rtp::session, error_period::start, switch_rtp::stats, error_period::stop, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_alloc, SWITCH_FALSE, SWITCH_LOG_DEBUG1, SWITCH_LOG_DEBUG3, switch_log_printf(), switch_micro_time_now(), SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_PAUSE, SWITCH_TRUE, and switch_rtp_numbers_t::variance.

Referenced by read_rtp_packet().

{
        switch_time_t current_time;
        int64_t diff_time = 0, cur_diff = 0;
        int seq;

        current_time = switch_micro_time_now() / 1000;

        if (rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] || rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] || rtp_session->dtmf_data.in_digit_ts) {
                reset_jitter_seq(rtp_session);
                return;
        }

        if (++rtp_session->jitter_lead < JITTER_LEAD_FRAMES || !rtp_session->stats.inbound.last_proc_time) {
                rtp_session->stats.inbound.last_proc_time = current_time;
                return;
        }

        diff_time = (current_time - rtp_session->stats.inbound.last_proc_time);
        seq = (int)(uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq);

        /* Burst and Packet Loss */
        rtp_session->stats.inbound.recved++;

        if (rtp_session->stats.inbound.last_processed_seq > 0 && seq > (int)(rtp_session->stats.inbound.last_processed_seq + 1)) {
                int lost = (seq - rtp_session->stats.inbound.last_processed_seq - 1);

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "%s Got: %s seq %d but expected: %d lost: %d\n", 
                                                  rtp_session_name(rtp_session),
                                                  rtp_type(rtp_session),
                                                  seq,
                                                  (rtp_session->stats.inbound.last_processed_seq + 1), lost);
                rtp_session->stats.inbound.last_loss++;

                if (rtp_session->stats.inbound.last_loss > 0 && rtp_session->stats.inbound.last_loss < LOST_BURST_CAPTURE) {
                        rtp_session->stats.inbound.loss[rtp_session->stats.inbound.last_loss] += lost;
                }

                rtp_session->bad_stream++;
                rtp_session->stats.inbound.flaws += lost;
        } else {
                rtp_session->stats.inbound.last_loss = 0;
        }
        
        rtp_session->stats.inbound.last_processed_seq = seq;

        /* Burst and Packet Loss */

        if (current_time > rtp_session->next_stat_check_time) {
                rtp_session->next_stat_check_time = current_time + 5000;
                burstr_calculate(rtp_session->stats.inbound.loss, rtp_session->stats.inbound.recved,
                                                 &(rtp_session->stats.inbound.burstrate), &(rtp_session->stats.inbound.lossrate));
                do_mos(rtp_session, SWITCH_TRUE);
        } else {
                do_mos(rtp_session, SWITCH_FALSE);
        }
        
        if (rtp_session->stats.inbound.last_loss || rtp_session->bad_stream) {
                if (rtp_session->session && (!rtp_session->stats.inbound.error_log || rtp_session->stats.inbound.error_log->stop)) {
                        struct error_period *error = switch_core_session_alloc(rtp_session->session, sizeof(*error));
                        error->start = switch_micro_time_now();
                        error->next = rtp_session->stats.inbound.error_log;
                        rtp_session->stats.inbound.error_log = error;
                }

                if (!rtp_session->stats.inbound.last_loss) {
                        if (++rtp_session->recovering_stream > (rtp_session->one_second * 3)) {
                                if (rtp_session->session && rtp_session->stats.inbound.error_log) {
                                        rtp_session->stats.inbound.error_log->stop = switch_micro_time_now();
                                }

                                rtp_session->bad_stream = 0;
                        }
                } else {
                        rtp_session->recovering_stream = 0;
                        rtp_session->bad_stream++;
                }
        } else {
                rtp_session->recovering_stream = 0;
                rtp_session->clean_stream++;
        }
        

        if ( diff_time < 0 ) {
                diff_time = -diff_time;
        }
        
        rtp_session->stats.inbound.jitter_n++;
        rtp_session->stats.inbound.jitter_add += diff_time;

        cur_diff = (int64_t)(diff_time - rtp_session->stats.inbound.mean_interval);
        
        rtp_session->stats.inbound.jitter_addsq += (cur_diff * cur_diff);
        rtp_session->stats.inbound.last_proc_time = current_time;

        if (rtp_session->stats.inbound.jitter_n > 0) {
                double ipdv;

                rtp_session->stats.inbound.mean_interval = (double)rtp_session->stats.inbound.jitter_add / (double)rtp_session->stats.inbound.jitter_n;

                if (!rtp_session->old_mean) {
                        rtp_session->old_mean = rtp_session->stats.inbound.mean_interval;
                }

                rtp_session->stats.inbound.variance = (double)rtp_session->stats.inbound.jitter_addsq / (double)rtp_session->stats.inbound.jitter_n;
                
                //printf("CHECK %d +%ld +%ld %f %f\n", rtp_session->timer.samplecount, diff_time, (diff_time * diff_time), rtp_session->stats.inbound.mean_interval, rtp_session->stats.inbound.variance);
                
                ipdv = rtp_session->old_mean - rtp_session->stats.inbound.mean_interval;

                if ( ipdv > IPDV_THRESHOLD ) { /* It shows Increasing Delays */
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG3, "Calculated Instantaneous Packet Delay Variation: %s packet %lf\n",
                                                          rtp_type(rtp_session), ipdv);
                }

                if ( rtp_session->stats.inbound.variance < rtp_session->stats.inbound.min_variance || rtp_session->stats.inbound.min_variance == 0 ) {
                        rtp_session->stats.inbound.min_variance = rtp_session->stats.inbound.variance;
                }

                if ( rtp_session->stats.inbound.variance > rtp_session->stats.inbound.max_variance ) {
                        rtp_session->stats.inbound.max_variance = rtp_session->stats.inbound.variance;
                }

                rtp_session->old_mean = rtp_session->stats.inbound.mean_interval;
        }
}

static int check_recv_payload ( switch_rtp_t *  rtp_session )

static

Definition at line 5085 of file switch_rtp.c.

References payload_map_s::allocated, switch_rtp::flag_mutex, switch_rtp::last_rtp_hdr, payload_map_s::negotiated, payload_map_s::next, switch_rtp::pmaps, payload_map_s::pt, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by read_rtp_packet(), and rtp_common_read().

{
        int ok = 1;

        if (rtp_session->pmaps && *rtp_session->pmaps) {
                payload_map_t *pmap;
                ok = 0;

                switch_mutex_lock(rtp_session->flag_mutex);

                for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {                                  
                        if (!pmap->negotiated) {
                                continue;
                        }

                        if (rtp_session->last_rtp_hdr.pt == pmap->pt) {
                                ok = 1;
                        }
                }
                switch_mutex_unlock(rtp_session->flag_mutex);
        }

        return ok;
}

static int check_rtcp_and_ice ( switch_rtp_t *  rtp_session )

static

Definition at line 1956 of file switch_rtp.c.

References _RTCP_PSFB_FIR, _RTCP_PSFB_PLI, _RTCP_PT_PSFB, _RTCP_PT_RR, _RTCP_PT_RTPFB, _RTCP_PT_SDES, _RTCP_PT_SR, _RTCP_RTPFB_NACK, _RTCP_RTPFB_TMMBN, _RTCP_RTPFB_TMMBR, _RTCP_SDES_CNAME, _RTCP_SDES_NOTE, rtcp_msg_t::body, calc_bw_exp(), switch_rtp::cn, switch_rtp::cng_pt, switch_rtcp_hdr_s::count, switch_rtcp_numbers_t::cycle, switch_rtp::fir_count, switch_rtp::fir_seq, switch_rtp::flags, switch_rtcp_ext_hdr_t::fmt, get_next_write_ts(), rtp_msg_t::header, rtcp_msg_t::header, switch_rtcp_numbers_t::high_ext_seq_recv, switch_rtp::ice, ice_out(), switch_rtp_ice_t::ice_user, switch_rtp_stats_t::inbound, INVALID_PT, switch_rtcp_numbers_t::last_rpt_cycle, switch_rtcp_numbers_t::last_rpt_ext_seq, switch_rtcp_numbers_t::last_rpt_ts, switch_rtp::last_write_samplecount, switch_rtcp_sdes_unit_s::length, switch_rtcp_ext_hdr_t::length, switch_rtcp_hdr_s::length, MAX_NACK, switch_rtcp_ext_hdr_t::p, switch_rtcp_hdr_s::p, switch_rtp_numbers_t::period_packet_count, switch_rtcp_numbers_t::period_pkt_count, switch_rtp::pli_count, switch_rtcp_ext_hdr_t::pt, rtcp_fir_t::r1, rtcp_fir_t::r2, rtcp_fir_t::r3, switch_rtcp_ext_hdr_t::recv_ssrc, switch_rtp::remote_ssrc, switch_rtcp_sender_report::report_block, switch_rtcp_receiver_report::report_block, switch_rtp_ice_t::rready, switch_rtp_stats_t::rtcp, rtcp_generate_report_block(), rtcp_generate_sender_info(), switch_rtp::rtcp_ice, switch_rtp::rtcp_interval, switch_rtp::rtcp_last_sent, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_send_msg, switch_rtp::rtcp_sent_packets, switch_rtp::rtcp_sock_output, rtp_session_name, rtp_type, switch_timer::samplecount, switch_rtp::samples_per_interval, switch_rtp::send_ctx, switch_rtp::send_msg, switch_rtcp_ext_hdr_t::send_ssrc, switch_rtcp_sender_report::sender_info, switch_rtcp_numbers_t::sent_pkt_count, rtcp_fir_t::seq, switch_rtp::session, SFF_NONE, switch_rtp::srtp_idx_rtcp, rtcp_fir_t::ssrc, rtcp_tmmbx_t::ssrc, switch_rtp::ssrc, switch_rtcp_sender_report::ssrc, switch_rtcp_receiver_report::ssrc, switch_rtp::stats, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, switch_get_addr(), switch_jb_pop_nack(), SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_RTP_FLAG_AUTO_CNG, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_NACK, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_RTCP_PASSTHRU, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, switch_rtp_test_flag(), switch_rtp_write_manual(), switch_sockaddr_get_port(), switch_socket_sendto(), SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_rtp::timer, switch_rtp::tmmbn, switch_rtp::tmmbr, switch_rtp::ts, switch_rtcp_sdes_unit_s::type, switch_rtcp_hdr_s::type, using_ice(), switch_rtcp_sdes_unit_s::value, switch_rtp::vb, switch_rtcp_ext_hdr_t::version, and switch_rtcp_hdr_s::version.

Referenced by read_rtp_packet(), rtp_common_read(), and switch_rtp_ping().

{
        int ret = 0;
        int rtcp_ok = 0, rtcp_fb = 0;
        switch_time_t now = switch_micro_time_now();
        int rate = 0, nack_ttl = 0;
        uint32_t cur_nack[MAX_NACK] = { 0 };

        if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
                rtp_session->flags[SWITCH_RTP_FLAG_AUTO_CNG] &&
                rtp_session->send_msg.header.ts &&
                rtp_session->cng_pt != INVALID_PT &&
                (rtp_session->timer.samplecount - rtp_session->last_write_samplecount >= rtp_session->samples_per_interval * 60)) {
                uint8_t data[10] = { 0 };
                switch_frame_flag_t frame_flags = SFF_NONE;
                data[0] = 65;
                rtp_session->cn++;

                get_next_write_ts(rtp_session, 0);
                rtp_session->send_msg.header.ts = htonl(rtp_session->ts);
                
                switch_rtp_write_manual(rtp_session, (void *) data, 2, 0, rtp_session->cng_pt, ntohl(rtp_session->send_msg.header.ts), &frame_flags);
                
                if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
                        rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
                }
        }

        rate = rtp_session->rtcp_interval;

        if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && rtp_session->vb) {
                int n;
                for (n = 0; n < MAX_NACK; n++) {
                        uint32_t nack = switch_jb_pop_nack(rtp_session->vb);

                        if (!nack) break;

                        cur_nack[nack_ttl++] = nack;
                }
        }



        if (rtp_session->rtcp_sent_packets < 4) {
                rate = 4000;
        } else  {
                if (rtp_session->pli_count || rtp_session->fir_count || nack_ttl || rtp_session->tmmbr || rtp_session->tmmbn) {
                        //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "MARK BW/FIR ETC %d %d\n", rtp_session->pli_count, rtp_session->fir_count);
                        rtcp_ok = 1;
                        rtcp_fb = 1;
                }
        }

        //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "TIME CHECK %d > %d\n", (int)((now - rtp_session->rtcp_last_sent) / 1000), rate);
        
        if (!rtcp_ok && (!rtp_session->rtcp_last_sent || (int)((now - rtp_session->rtcp_last_sent) / 1000) > rate)) {
                //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "TIME UP\n");
                rtcp_ok = 1;
        }
        
        if (rtcp_ok && using_ice(rtp_session)) {
                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                        if (!rtp_session->ice.rready) {
                                rtcp_ok = 0;
                        }
                } else {
                        if (!rtp_session->rtcp_ice.rready) {
                                rtcp_ok = 0;
                        }
                }
        }

        //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "WTF %d %d %d %d\n", rate, rtp_session->rtcp_sent_packets, rtcp_ok, nack_ttl);
        
        if (rtp_session->rtcp_sock_output && rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] && !rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] && rtcp_ok) {
                switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
                struct switch_rtcp_receiver_report *rr;
                struct switch_rtcp_sender_report *sr;
                struct switch_rtcp_report_block *rtcp_report_block;
                switch_size_t rtcp_bytes = sizeof(struct switch_rtcp_hdr_s)+sizeof(uint32_t); /* add size of the packet header and the ssrc */
                switch_rtcp_hdr_t *sdes;
                uint8_t *p;
                switch_size_t sdes_bytes = sizeof(struct switch_rtcp_hdr_s);
                uint32_t *ssrc;
                switch_rtcp_sdes_unit_t *unit;

                if (!rtcp_fb) {
                        rtp_session->rtcp_last_sent = now;
                        rtp_session->rtcp_sent_packets++;
                }
                
                rtp_session->rtcp_send_msg.header.version = 2;
                rtp_session->rtcp_send_msg.header.p = 0;
                rtp_session->rtcp_send_msg.header.count = 1;

                
                if (!rtp_session->stats.rtcp.sent_pkt_count) {
                        rtp_session->rtcp_send_msg.header.type = _RTCP_PT_RR; /* Receiver report */
                        rr=(struct switch_rtcp_receiver_report*) rtp_session->rtcp_send_msg.body;
                        rr->ssrc = htonl(rtp_session->ssrc);
                        rtcp_report_block = &rr->report_block;
                        rtcp_bytes += sizeof(struct switch_rtcp_report_block);
                } else {
                        struct switch_rtcp_sender_info *rtcp_sender_info;
                        rtp_session->rtcp_send_msg.header.type = _RTCP_PT_SR; /* Sender report */
                        sr = (struct switch_rtcp_sender_report*) rtp_session->rtcp_send_msg.body;
                        sr->ssrc = htonl(rtp_session->ssrc);
                        rtcp_sender_info = &sr->sender_info;
                        rtcp_generate_sender_info(rtp_session, rtcp_sender_info);
                        rtcp_report_block = &sr->report_block;
                        rtcp_bytes += sizeof(struct switch_rtcp_sender_info) + sizeof(struct switch_rtcp_report_block);
                }
                rtcp_generate_report_block(rtp_session, rtcp_report_block);

                rtp_session->rtcp_send_msg.header.length = htons((uint16_t)(rtcp_bytes / 4) - 1);
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        //if (rtp_session->remote_ssrc == 0) {
                        //      rtp_session->remote_ssrc = rtp_session->stats.rtcp.peer_ssrc;
                        //}
                        
                        //if (rtp_session->remote_ssrc == 0) {
                        //      rtp_session->remote_ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc);
                        //}
                        

                        if (rtp_session->pli_count) {
                                switch_rtcp_ext_hdr_t *ext_hdr;

                                p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
                                ext_hdr = (switch_rtcp_ext_hdr_t *) p;
                        
                                ext_hdr->version = 2;
                                ext_hdr->p = 0;
                                ext_hdr->fmt = _RTCP_PSFB_PLI;
                                ext_hdr->pt = _RTCP_PT_PSFB;
                        
                                ext_hdr->send_ssrc = htonl(rtp_session->ssrc);
                                ext_hdr->recv_ssrc = htonl(rtp_session->remote_ssrc);
                        
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP PLI\n");
                        
                                ext_hdr->length = htons((uint8_t)(sizeof(switch_rtcp_ext_hdr_t) / 4) - 1); 
                                rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t);
                                rtp_session->pli_count = 0;
                        }

                        if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && nack_ttl > 0) {
                                int n = 0;

                                for (n = 0; n < nack_ttl; n++) {
                                        switch_rtcp_ext_hdr_t *ext_hdr;
                                        uint32_t *nack;
                                        p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
                                        ext_hdr = (switch_rtcp_ext_hdr_t *) p;
                                        
                                        ext_hdr->version = 2;
                                        ext_hdr->p = 0;
                                        ext_hdr->fmt = _RTCP_RTPFB_NACK;
                                        ext_hdr->pt = _RTCP_PT_RTPFB;
                                        ext_hdr->send_ssrc = htonl(rtp_session->ssrc);
                                        ext_hdr->recv_ssrc = htonl(rtp_session->remote_ssrc);
                                        ext_hdr->length = htons(3);
                                        p += sizeof(switch_rtcp_ext_hdr_t);
                                        nack = (uint32_t *) p;
                                        *nack = cur_nack[n];

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP NACK %u\n", 
                                                                          ntohs(*nack & 0xFFFF));
                                
                                        rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(cur_nack[n]);
                                        cur_nack[n] = 0;
                                }

                                nack_ttl = 0;
                        }
                        
                        if (rtp_session->fir_count) {
                                switch_rtcp_ext_hdr_t *ext_hdr;
                                rtcp_fir_t *fir;

                                p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
                                ext_hdr = (switch_rtcp_ext_hdr_t *) p;

                                p += sizeof(switch_rtcp_ext_hdr_t);
                                fir = (rtcp_fir_t *) p;
                        
                                ext_hdr->version = 2;
                                ext_hdr->p = 0;
                                ext_hdr->fmt = _RTCP_PSFB_FIR;
                                ext_hdr->pt = _RTCP_PT_PSFB;
                        
                                ext_hdr->send_ssrc = htonl(rtp_session->ssrc);
                                ext_hdr->recv_ssrc = 0;
                        
                                fir->ssrc = htonl(rtp_session->remote_ssrc);
                                fir->seq = rtp_session->fir_seq;
                                fir->r1 = fir->r2 = fir->r3 = 0;

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP FIR SEQ %d\n", rtp_session->fir_seq);

                                rtp_session->fir_seq++;
                        
                                ext_hdr->length = htons((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_fir_t)) / 4) - 1); 
                                rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_fir_t);
                                rtp_session->fir_count = 0;
                        }

                        //if (!rtp_session->tmmbr && rtp_session->cur_tmmbr) {
                        //      rtp_session->tmmbr = rtp_session->cur_tmmbr;
                        //}

                        while (rtp_session->tmmbr || rtp_session->tmmbn) {
                                switch_rtcp_ext_hdr_t *ext_hdr;
                                rtcp_tmmbx_t *tmmbx;
                                uint32_t bps = 0;
                                p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
                                ext_hdr = (switch_rtcp_ext_hdr_t *) p;

                                p += sizeof(switch_rtcp_ext_hdr_t);
                                tmmbx = (rtcp_tmmbx_t *) p;

                                ext_hdr->version = 2;
                                ext_hdr->p = 0;
                                ext_hdr->pt = _RTCP_PT_RTPFB;
                                ext_hdr->send_ssrc = htonl(rtp_session->ssrc);
                                ext_hdr->recv_ssrc = 0;

                                if (rtp_session->tmmbr) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP TMMBR %u\n", rtp_session->tmmbr);
                                        ext_hdr->fmt = _RTCP_RTPFB_TMMBR;
                                        bps = rtp_session->tmmbr;
                                        rtp_session->tmmbr = 0;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP TMMBN %u\n", rtp_session->tmmbr);
                                        ext_hdr->fmt = _RTCP_RTPFB_TMMBN;
                                        bps = rtp_session->tmmbn;
                                        rtp_session->tmmbn = 0;
                                }

                                tmmbx->ssrc = htonl(rtp_session->remote_ssrc);
                                calc_bw_exp(bps, 17, tmmbx);
                                
                                ext_hdr->length = htons((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_tmmbx_t)) / 4) - 1);
                                rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_tmmbx_t);                     
                        }

                }

                //SDES + CNAME
                p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
                sdes = (switch_rtcp_hdr_t *) p;
                sdes->version = 2;
                sdes->type = _RTCP_PT_SDES;
                sdes->count = 1;
                sdes->p = 0;
                p = (uint8_t *) (sdes) + sdes_bytes;
                ssrc = (uint32_t *) p;
                *ssrc = htonl(rtp_session->ssrc);
                sdes_bytes += sizeof(uint32_t);


                p = (uint8_t *) (sdes) + sdes_bytes;
                unit = (switch_rtcp_sdes_unit_t *) p;
                unit->type = _RTCP_SDES_CNAME;
                snprintf((char *)unit->value, 80, "%x", rtp_session->ssrc);
                unit->length = strlen((char *)unit->value);
                sdes_bytes += sizeof(switch_rtcp_sdes_unit_t) + unit->length;


                p += sizeof(switch_rtcp_sdes_unit_t) + unit->length;
                unit = (switch_rtcp_sdes_unit_t *) p;
                unit->type = _RTCP_SDES_NOTE;
                snprintf((char *)unit->value, 80, "FreeSWITCH.org -- Come to ClueCon.com");
                unit->length = strlen((char *)unit->value);
                sdes_bytes += sizeof(switch_rtcp_sdes_unit_t) + unit->length;           

                sdes_bytes ++;//END

                sdes_bytes += 4 - (sdes_bytes % 4);
                
                sdes->length = htons((uint16_t)(sdes_bytes / 4) - 1);
                rtcp_bytes += sdes_bytes;

                /* Prepare next report */

                stats->last_rpt_cycle = stats->cycle;
                stats->last_rpt_ext_seq = stats->high_ext_seq_recv;
                stats->last_rpt_ts = rtp_session->timer.samplecount;
                stats->period_pkt_count = 0;
                stats->sent_pkt_count = 0;



#ifdef ENABLE_SRTP
                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
                        int sbytes = (int) rtcp_bytes;
                        int stat = srtp_protect_rtcp(rtp_session->send_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_send_msg.header, &sbytes);
                        
                        if (stat) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP RTCP protection failed with code %d\n", stat);
                                goto end;
                        } else {
                                rtcp_bytes = sbytes;
                        }

                }
#endif

#ifdef ENABLE_ZRTP
                /* ZRTP Send */
                if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                        unsigned int sbytes = (int) rtcp_bytes;
                        zrtp_status_t stat = zrtp_status_fail;

                        stat = zrtp_process_rtcp(rtp_session->zrtp_stream, (void *) &rtp_session->rtcp_send_msg, &sbytes);

                        switch (stat) {
                        case zrtp_status_ok:
                                break;
                        case zrtp_status_drop:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
                                ret = (int)rtcp_bytes;
                                goto end;
                                break;
                        case zrtp_status_fail:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                break;
                        default:
                                break;
                        }

                        rtcp_bytes = sbytes;
                }
#endif
                //#define DEBUG_EXTRA
#ifdef DEBUG_EXTRA
                {
                        const char *old_host;
                        char bufb[50];
                        old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->rtcp_remote_addr);
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "%s SEND %s RTCP %s:%d %ld\n", 
                                                          rtp_session_name(rtp_session),
                                                          rtp_type(rtp_session),
                                                          old_host,
                                                          switch_sockaddr_get_port(rtp_session->rtcp_remote_addr),
                                                          rtcp_bytes);
                }
#endif
                if (switch_socket_sendto(rtp_session->rtcp_sock_output, rtp_session->rtcp_remote_addr, 0, (void *)&rtp_session->rtcp_send_msg, &rtcp_bytes ) != SWITCH_STATUS_SUCCESS) {                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG,"RTCP packet not written\n");
                } else {
                        rtp_session->stats.inbound.period_packet_count = 0;
                }
        }
        
        if (rtp_session->ice.ice_user) {
                if (ice_out(rtp_session, &rtp_session->ice) == SWITCH_STATUS_GENERR) {
                        ret = -1;
                        goto end;
                }
        }

        if (!rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                if (rtp_session->rtcp_ice.ice_user) {
                        if (ice_out(rtp_session, &rtp_session->rtcp_ice) == SWITCH_STATUS_GENERR) {
                                ret = -1;
                                goto end;
                        }
                }
        }

 end:

        return ret;
}

static void do_2833 ( switch_rtp_t *  rtp_session )

static

Definition at line 4784 of file switch_rtp.c.

References switch_rtp::delay_samples, switch_dtmf_t::digit, switch_rtp::dtmf_data, switch_rtp_numbers_t::dtmf_packet_count, switch_rtp_rfc2833_data::dtmf_queue, switch_dtmf_t::duration, switch_rtp::flags, switch_rtp::interdigit_delay, switch_rtp::last_write_samplecount, switch_rtp::last_write_ts, switch_rtp::max_next_write_samplecount, memset(), switch_rtp::need_mark, switch_rtp::next_write_samplecount, switch_rtp_rfc2833_data::out_digit, switch_rtp_rfc2833_data::out_digit_dur, switch_rtp_rfc2833_data::out_digit_packet, switch_rtp_rfc2833_data::out_digit_sofar, switch_rtp_rfc2833_data::out_digit_sub_sofar, switch_rtp_stats_t::outbound, switch_rtp::queue_delay, switch_rtp_numbers_t::raw_bytes, RTP_BUG_CISCO_SKIP_MARK_BIT_2833, RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833, switch_rtp::rtp_bugs, switch_timer::samplecount, switch_rtp::samples_per_interval, switch_rtp::sending_dtmf, switch_rtp::seq, switch_rtp::session, set_dtmf_delay(), switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_char_to_rfc2833(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_queue_size(), switch_queue_trypop(), SWITCH_RTP_FLAG_RESET, SWITCH_RTP_FLAG_USE_TIMER, switch_rtp_write_manual(), SWITCH_STATUS_SUCCESS, switch_rtp::te, switch_rtp::timer, and switch_rtp_rfc2833_data::timestamp_dtmf.

Referenced by rtp_common_read().

{
        switch_frame_flag_t flags = 0;
        uint32_t samples = rtp_session->samples_per_interval;

        if (!rtp_session->last_write_ts) {
                return;
        }
        
        if (rtp_session->dtmf_data.out_digit_dur > 0) {
                int x, loops = 1;

                rtp_session->dtmf_data.out_digit_sofar += samples;
                rtp_session->dtmf_data.out_digit_sub_sofar += samples;

                if (rtp_session->dtmf_data.out_digit_sub_sofar > 0xFFFF) {
                        rtp_session->dtmf_data.out_digit_sub_sofar = samples;
                        rtp_session->dtmf_data.timestamp_dtmf += 0xFFFF;
                }

                if (rtp_session->dtmf_data.out_digit_sofar >= rtp_session->dtmf_data.out_digit_dur) {
                        rtp_session->dtmf_data.out_digit_packet[1] |= 0x80;
                        loops = 3;
                }

                rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
                rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;

                for (x = 0; x < loops; x++) {
                        switch_size_t wrote = switch_rtp_write_manual(rtp_session,
                                                                                                                  rtp_session->dtmf_data.out_digit_packet, 4, 0,
                                                                                                                  rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);

                        rtp_session->stats.outbound.raw_bytes += wrote;
                        rtp_session->stats.outbound.dtmf_packet_count++;

                        if (loops == 1) {
                                rtp_session->last_write_ts += samples;

                                if (rtp_session->rtp_bugs & RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833) {
                                        rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts;
                                }
                        }

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Send %s packet for [%c] ts=%u dur=%d/%d/%d seq=%d lw=%u\n",
                                                          loops == 1 ? "middle" : "end", rtp_session->dtmf_data.out_digit,
                                                          rtp_session->dtmf_data.timestamp_dtmf,
                                                          rtp_session->dtmf_data.out_digit_sofar,
                                                          rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq, rtp_session->last_write_ts);
                }

                if (loops != 1) {
                        rtp_session->sending_dtmf = 0;
                        rtp_session->need_mark = 1;
                        
                        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                                rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
                        }

                        rtp_session->dtmf_data.out_digit_dur = 0;

                        if (rtp_session->interdigit_delay) {
                                set_dtmf_delay(rtp_session, rtp_session->interdigit_delay, rtp_session->interdigit_delay * 10);
                        }

                        return;
                }
        }

        if (!rtp_session->dtmf_data.out_digit_dur && rtp_session->dtmf_data.dtmf_queue && switch_queue_size(rtp_session->dtmf_data.dtmf_queue)) {
                void *pop;

                if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                        if (rtp_session->timer.samplecount < rtp_session->next_write_samplecount) {
                                return;
                        }

                        if (rtp_session->timer.samplecount >= rtp_session->max_next_write_samplecount) {
                                rtp_session->queue_delay = 0;
                        }

                } else if (rtp_session->queue_delay) {
                        if (rtp_session->delay_samples >= rtp_session->samples_per_interval) {
                                rtp_session->delay_samples -= rtp_session->samples_per_interval;
                        } else {
                                rtp_session->delay_samples = 0;
                        }

                        if (!rtp_session->delay_samples) {
                                rtp_session->queue_delay = 0;
                        }
                }
                
                if (rtp_session->queue_delay) {
                        return;
                }


                if (!rtp_session->sending_dtmf) {
                        rtp_session->sending_dtmf = 1;
                }

                if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                        switch_dtmf_t *rdigit = pop;
                        switch_size_t wrote;

                        if (rdigit->digit == 'w') {
                                set_dtmf_delay(rtp_session, 500, 0);
                                free(rdigit);
                                return;
                        }

                        if (rdigit->digit == 'W') {
                                set_dtmf_delay(rtp_session, 1000, 0);
                                free(rdigit);
                                return;
                        }
                        

                        
                        memset(rtp_session->dtmf_data.out_digit_packet, 0, 4);
                        rtp_session->dtmf_data.out_digit_sofar = samples;
                        rtp_session->dtmf_data.out_digit_sub_sofar = samples;
                        rtp_session->dtmf_data.out_digit_dur = rdigit->duration;
                        rtp_session->dtmf_data.out_digit = rdigit->digit;
                        rtp_session->dtmf_data.out_digit_packet[0] = (unsigned char) switch_char_to_rfc2833(rdigit->digit);
                        rtp_session->dtmf_data.out_digit_packet[1] = 13;
                        rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
                        rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;


                        rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts + samples;
                        rtp_session->last_write_ts = rtp_session->dtmf_data.timestamp_dtmf;
                        rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;

                        wrote = switch_rtp_write_manual(rtp_session,
                                                                                        rtp_session->dtmf_data.out_digit_packet,
                                                                                        4,
                                                                                        rtp_session->rtp_bugs & RTP_BUG_CISCO_SKIP_MARK_BIT_2833 ? 0 : 1,
                                                                                        rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);

                        
                        rtp_session->stats.outbound.raw_bytes += wrote;
                        rtp_session->stats.outbound.dtmf_packet_count++;
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Send start packet for [%c] ts=%u dur=%d/%d/%d seq=%d lw=%u\n",
                                                          rtp_session->dtmf_data.out_digit,
                                                          rtp_session->dtmf_data.timestamp_dtmf,
                                                          rtp_session->dtmf_data.out_digit_sofar,
                                                          rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq, rtp_session->last_write_ts);

                        free(rdigit);
                }
        }
}

static int do_dtls ( switch_rtp_t *  rtp_session, switch_dtls_t *  dtls  )

static

Definition at line 3144 of file switch_rtp.c.

References buf, switch_dtls_s::bytes, switch_dtls_s::data, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_dtls_s::read_bio, switch_rtp_ice_t::ready, switch_dtls_s::remote_addr, switch_rtp_ice_t::rready, rtp_type, switch_rtp::session, switch_dtls_s::sock_output, switch_dtls_s::ssl, switch_dtls_s::state, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_ERROR, switch_log_printf(), switch_socket_sendto(), SWITCH_STATUS_SUCCESS, and switch_dtls_s::write_bio.

Referenced by read_rtcp_packet(), and read_rtp_packet().

{
        int r = 0, ret = 0, len;
        switch_size_t bytes;
        unsigned char buf[4096] = "";
        int ready = rtp_session->ice.ice_user ? (rtp_session->ice.rready && rtp_session->ice.ready) : 1;
        

        if (!dtls->bytes && !ready) {
                return 0;
        }

        if ((ret = BIO_write(dtls->read_bio, dtls->data, (int)dtls->bytes)) != (int)dtls->bytes && dtls->bytes > 0) {
                ret = SSL_get_error(dtls->ssl, ret);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet read err %d\n", rtp_type(rtp_session), ret);
        }

        if (dtls_states[dtls->state]) {
                r = dtls_states[dtls->state](rtp_session, dtls);
        }

        if ((len = BIO_read(dtls->write_bio, buf, sizeof(buf))) > 0) {
                bytes = len;

                if (switch_socket_sendto(dtls->sock_output, dtls->remote_addr, 0, (void *)buf, &bytes ) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet not written\n", rtp_type(rtp_session));
                }
        }


        
        return r;
}

static switch_size_t do_flush ( switch_rtp_t *  rtp_session, int  force, switch_size_t  bytes_in  )

static

Definition at line 4983 of file switch_rtp.c.

References FALSE, switch_rtp::flags, switch_rtp_numbers_t::flush_packet_count, switch_rtp::from_addr, handle_rfc2833(), switch_rtp_stats_t::inbound, switch_rtp::jb, jb_valid(), switch_rtp::last_rtp_hdr, switch_rtp_numbers_t::packet_count, switch_rtp::pause_jb, switch_rtp_numbers_t::raw_bytes, READ_DEC, READ_INC, switch_rtp::recv_msg, switch_rtp::recv_te, reset_jitter_seq(), rtp_header_len, switch_rtp::session, switch_rtp::sock_input, switch_rtp::stats, switch_channel_get_name(), SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_channel(), switch_core_session_request_video_refresh(), switch_jb_reset(), SWITCH_LOG_CONSOLE, SWITCH_LOG_ERROR, switch_log_printf(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_DEBUG_RTP_READ, SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_VIDEO, switch_rtp_ready(), switch_rtp_set_flag(), SWITCH_SO_NONBLOCK, switch_socket_opt_set(), switch_socket_recvfrom(), TRUE, switch_rtp::vb, and switch_rtp::vbw.

Referenced by rtp_common_read().

{
        int was_blocking = 0;
        switch_size_t bytes;
        uint32_t flushed = 0;
        switch_size_t bytes_out = 0;
        
        if (!switch_rtp_ready(rtp_session)) {
                return 0;
        }

        reset_jitter_seq(rtp_session);

        if (!force) {
                if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || 
                        rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] ||
                        rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]
                        ) {
                        return 0;
                }
        }
        
        READ_INC(rtp_session);

        if (switch_rtp_ready(rtp_session) ) {

                if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
                        //switch_jb_reset(rtp_session->jb);
                        bytes_out = bytes_in;
                        goto end;
                }

                if (rtp_session->vbw) {
                        switch_jb_reset(rtp_session->vbw);
                }

                if (rtp_session->vb) {
                        //switch_jb_reset(rtp_session->vb);
                        bytes_out = bytes_in;
                        goto end;
                }
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session),
                                                          SWITCH_LOG_CONSOLE, "%s FLUSH\n",
                                                          rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName"
                                                          );
                }

                if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK]) {
                        was_blocking = 1;
                        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
                        switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, TRUE);
                }

                do {
                        if (switch_rtp_ready(rtp_session)) {
                                bytes = sizeof(rtp_msg_t);
                                switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, &bytes);
                                
                                if (bytes) {
                                        int do_cng = 0;

                                        /* Make sure to handle RFC2833 packets, even if we're flushing the packets */
                                        if (bytes > rtp_header_len && rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
                                                handle_rfc2833(rtp_session, bytes, &do_cng);
#ifdef DEBUG_2833
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "*** RTP packet handled in flush loop %d ***\n", do_cng);
#endif
                                        }

                                        flushed++;

                                        rtp_session->stats.inbound.raw_bytes += bytes;
                                        rtp_session->stats.inbound.flush_packet_count++;
                                        rtp_session->stats.inbound.packet_count++;
                                }
                        } else {
                                break;
                        }
                } while (bytes > 0);

                if (was_blocking && switch_rtp_ready(rtp_session)) {
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
                        switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK, FALSE);
                }
        

                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->session) {
                        //int type = 1; // sum flags: 1 encoder; 2; decoder
                        //switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_READ, SCC_VIDEO_RESET, SCCT_INT, (void *)&type, NULL, NULL);
                        switch_core_session_request_video_refresh(rtp_session->session);
                }
        }

 end:
        
        READ_DEC(rtp_session);

        return bytes_out;
}

static void do_mos ( switch_rtp_t *  rtp_session, int  force  )

static

Definition at line 1521 of file switch_rtp.c.

References switch_rtp::bad_stream, switch_rtp::consecutive_flaws, switch_rtp_numbers_t::flaws, switch_rtp_stats_t::inbound, switch_rtp_numbers_t::last_flaw, switch_rtp_numbers_t::max_variance, switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, switch_rtp_numbers_t::R, switch_rtp_numbers_t::recved, rtp_session_name, rtp_type, switch_rtp::session, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG3, switch_log_printf(), and switch_rtp_numbers_t::variance.

Referenced by check_jitter(), rtp_common_read(), switch_rtp_get_stats(), and switch_rtp_sync_stats().

                                                         {

        if ((switch_size_t)rtp_session->stats.inbound.recved < rtp_session->stats.inbound.flaws) {
                rtp_session->stats.inbound.flaws = 0;
        }

        if (rtp_session->stats.inbound.recved > 0 && 
                rtp_session->stats.inbound.flaws && (force || rtp_session->stats.inbound.last_flaw != rtp_session->stats.inbound.flaws)) {
                int R;

                if (rtp_session->consecutive_flaws++) {
                        int diff, penalty;

                        diff = (rtp_session->stats.inbound.flaws - rtp_session->stats.inbound.last_flaw);

                        if (diff < 1) diff = 1;

                        penalty = diff * 2;
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3, "%s %s %d consecutive flaws, adding %d flaw penalty\n", 
                                                          rtp_session_name(rtp_session), rtp_type(rtp_session), 
                                                          rtp_session->consecutive_flaws, penalty);
                        rtp_session->bad_stream++;
                        rtp_session->stats.inbound.flaws += penalty;
                }

                R = (int)((double)((double)(rtp_session->stats.inbound.recved - rtp_session->stats.inbound.flaws) / (double)rtp_session->stats.inbound.recved) * 100.0);
                
                if (R < 0 || R > 100) R = 100;

                rtp_session->stats.inbound.R = R;
                rtp_session->stats.inbound.mos = 1 + (0.035) * R + (.000007) * R * (R-60) * (100-R);
                rtp_session->stats.inbound.last_flaw = rtp_session->stats.inbound.flaws;
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3, "%s %s stat %0.2f %ld/%d flaws: %ld mos: %0.2f v: %0.2f %0.2f/%0.2f\n",
                                                  rtp_session_name(rtp_session),
                                                  rtp_type(rtp_session),
                                                  rtp_session->stats.inbound.R,
                                                  (long int)(rtp_session->stats.inbound.recved - rtp_session->stats.inbound.flaws), rtp_session->stats.inbound.recved,
                                                  (long int)rtp_session->stats.inbound.flaws,
                                                  rtp_session->stats.inbound.mos,
                                                  rtp_session->stats.inbound.variance,
                                                  rtp_session->stats.inbound.min_variance,
                                                  rtp_session->stats.inbound.max_variance
                                                  );
        } else {
                rtp_session->consecutive_flaws = 0;
        }
}

static int dtls_state_fail ( switch_rtp_t *  rtp_session, switch_dtls_t *  dtls  )

static

Definition at line 3089 of file switch_rtp.c.

References switch_rtp::session, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_hangup, and switch_core_session_get_channel().

{
        if (rtp_session->session) {
                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
        }

        return -1;
}

static int dtls_state_handshake ( switch_rtp_t *  rtp_session, switch_dtls_t *  dtls  )

static

Definition at line 3100 of file switch_rtp.c.

References DS_FAIL, DS_SETUP, dtls_set_state, rtp_type, switch_rtp::session, switch_dtls_s::ssl, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_ERROR, and switch_log_printf().

{
        int ret;

        if ((ret = SSL_do_handshake(dtls->ssl)) != 1){
                switch((ret = SSL_get_error(dtls->ssl, ret))){
                case SSL_ERROR_WANT_READ:
                case SSL_ERROR_WANT_WRITE:
                case SSL_ERROR_NONE:
                        break;
                default:
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s Handshake failure %d\n", rtp_type(rtp_session), ret);
                        dtls_set_state(dtls, DS_FAIL);
                        return -1;
                }
        }

        if (SSL_is_init_finished(dtls->ssl)) {
                dtls_set_state(dtls, DS_SETUP);
        }

        return 0;
}

static const char* dtls_state_names ( dtls_state_t  s )

static

Definition at line 2989 of file switch_rtp.c.

References DS_INVALID.

{
        if (s > DS_INVALID) {
                s = DS_INVALID;
        }

        return dtls_state_names_t[s];
}

static int dtls_state_ready ( switch_rtp_t *  rtp_session, switch_dtls_t *  dtls  )

static

Definition at line 3072 of file switch_rtp.c.

References switch_rtp::flags, switch_dtls_s::new_state, switch_rtp::session, switch_core_session_get_partner, switch_core_session_request_video_refresh(), switch_core_session_rwunlock(), SWITCH_RTP_FLAG_VIDEO, and SWITCH_STATUS_SUCCESS.

{

        if (dtls->new_state) {
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        switch_core_session_t *other_session;
                        
                        if (rtp_session->session && switch_core_session_get_partner(rtp_session->session, &other_session) == SWITCH_STATUS_SUCCESS) {
                                switch_core_session_request_video_refresh(other_session);
                                switch_core_session_rwunlock(other_session);
                        }
                }
                dtls->new_state = 0;
        }
        return 0;
}

static int dtls_state_setup ( switch_rtp_t *  rtp_session, switch_dtls_t *  dtls  )

static

Definition at line 3005 of file switch_rtp.c.

References AES_CM_128_HMAC_SHA1_80, cr_keylen, cr_kslen, cr_saltlen, DS_FAIL, DS_READY, switch_rtp::dtls, dtls_set_state, DTLS_TYPE_CLIENT, DTLS_TYPE_SERVER, switch_dtls_s::remote_fp, switch_rtp::rtcp_dtls, rtp_type, switch_rtp::session, switch_dtls_s::ssl, SWITCH_CHANNEL_SESSION_LOG, switch_core_cert_extract_fingerprint(), switch_core_cert_verify(), SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_rtp_add_crypto_key(), SWITCH_RTP_CRYPTO_RECV, SWITCH_RTP_CRYPTO_RECV_RTCP, SWITCH_RTP_CRYPTO_SEND, SWITCH_RTP_CRYPTO_SEND_RTCP, and switch_dtls_s::type.

{
        X509 *cert;
        int r = 0;

        if ((dtls->type & DTLS_TYPE_SERVER)) {
                r = 1;
        } else if ((cert = SSL_get_peer_certificate(dtls->ssl))) {
                switch_core_cert_extract_fingerprint(cert, dtls->remote_fp);
                r = switch_core_cert_verify(dtls->remote_fp);
                X509_free(cert);
        }

        if (!r) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s Fingerprint Verification Failed!\n", rtp_type(rtp_session));
                dtls_set_state(dtls, DS_FAIL);
                return -1;
        } else {
                uint8_t raw_key_data[cr_kslen*2] = { 0 };
                unsigned char *local_key, *remote_key, *local_salt, *remote_salt;
                unsigned char local_key_buf[cr_kslen] = {0}, remote_key_buf[cr_kslen] = {0};
                
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "%s Fingerprint Verified.\n", rtp_type(rtp_session));

#ifdef HAVE_OPENSSL_DTLS_SRTP
                if (!SSL_export_keying_material(dtls->ssl, raw_key_data, sizeof(raw_key_data), "EXTRACTOR-dtls_srtp", 19, NULL, 0, 0)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "%s Key material export failure\n", rtp_type(rtp_session));
                        dtls_set_state(dtls, DS_FAIL);
                        return -1;
                }
#else
                return -1;
#endif
                
                if ((dtls->type & DTLS_TYPE_CLIENT)) {
                        local_key = raw_key_data;
                        remote_key = local_key + cr_keylen;
                        local_salt = remote_key + cr_keylen;
                        remote_salt = local_salt + cr_saltlen;
                        
                } else {
                        remote_key = raw_key_data;
                        local_key = remote_key + cr_keylen;
                        remote_salt = local_key + cr_keylen;
                        local_salt = remote_salt + cr_saltlen;
                }

                memcpy(local_key_buf, local_key, cr_keylen);
                memcpy(local_key_buf + cr_keylen, local_salt, cr_saltlen);

                memcpy(remote_key_buf, remote_key, cr_keylen);
                memcpy(remote_key_buf + cr_keylen, remote_salt, cr_saltlen);
                
                if (dtls == rtp_session->rtcp_dtls && rtp_session->rtcp_dtls != rtp_session->dtls) {
                        switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_SEND_RTCP, 0, AES_CM_128_HMAC_SHA1_80, local_key_buf, cr_kslen);
                        switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_RECV_RTCP, 0, AES_CM_128_HMAC_SHA1_80, remote_key_buf, cr_kslen);
                } else {
                        switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_SEND, 0, AES_CM_128_HMAC_SHA1_80, local_key_buf, cr_kslen);
                        switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_RECV, 0, AES_CM_128_HMAC_SHA1_80, remote_key_buf, cr_kslen);
                }
        }

        dtls_set_state(dtls, DS_READY);

        return 0;
}

static switch_status_t enable_local_rtcp_socket ( switch_rtp_t *  rtp_session, const char **  err  )

static

Definition at line 2522 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::from_addr, switch_rtp::local_host_str, switch_rtp::local_port, switch_rtp::pool, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_local_addr, switch_rtp::rtcp_read_pollfd, switch_rtp::rtcp_sock_input, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_get_addr(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_POLLERR, SWITCH_POLLIN, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_SO_REUSEADDR, switch_sockaddr_get_family(), switch_sockaddr_get_port(), switch_sockaddr_info_get(), switch_socket_bind(), switch_socket_close(), switch_socket_create(), switch_socket_create_pollset(), switch_socket_opt_set(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_UNSPEC.

Referenced by switch_rtp_activate_rtcp(), and switch_rtp_set_local_address().

                                                                                             {

        const char *host = rtp_session->local_host_str;
        switch_port_t port = rtp_session->local_port;
        switch_socket_t *rtcp_new_sock = NULL, *rtcp_old_sock = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        char bufa[50];

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                if (switch_sockaddr_info_get(&rtp_session->rtcp_local_addr, host, SWITCH_UNSPEC, port+1, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                        *err = "RTCP Local Address Error!";
                        goto done;
                }
                
                if (switch_socket_create(&rtcp_new_sock, switch_sockaddr_get_family(rtp_session->rtcp_local_addr), SOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                        *err = "RTCP Socket Error!";
                        goto done;
                }
                
                if (switch_socket_opt_set(rtcp_new_sock, SWITCH_SO_REUSEADDR, 1) != SWITCH_STATUS_SUCCESS) {
                        *err = "RTCP Socket Error!";
                        goto done;
                }
                
                if (switch_socket_bind(rtcp_new_sock, rtp_session->rtcp_local_addr) != SWITCH_STATUS_SUCCESS) {
                        *err = "RTCP Bind Error!";
                        goto done;
                }
                
                if (switch_sockaddr_info_get(&rtp_session->rtcp_from_addr, switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr),
                                                                                         SWITCH_UNSPEC, switch_sockaddr_get_port(rtp_session->from_addr) + 1, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
                        *err = "RTCP From Address Error!";
                        goto done;
                }

                rtcp_old_sock = rtp_session->rtcp_sock_input;
                rtp_session->rtcp_sock_input = rtcp_new_sock;
                rtcp_new_sock = NULL;

                switch_socket_create_pollset(&rtp_session->rtcp_read_pollfd, rtp_session->rtcp_sock_input, SWITCH_POLLIN | SWITCH_POLLERR, rtp_session->pool);

 done:
                
                if (*err) {
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating rtcp [%s]\n", *err);
                        status = SWITCH_STATUS_FALSE;
                }

                if (rtcp_new_sock) {
                        switch_socket_close(rtcp_new_sock);
                }
                        
                if (rtcp_old_sock) {
                        switch_socket_close(rtcp_old_sock);
                }
        } else {
                status = SWITCH_STATUS_FALSE;
        }

        return status;
}

static switch_status_t enable_remote_rtcp_socket ( switch_rtp_t *  rtp_session, const char **  err  )

static

Definition at line 2478 of file switch_rtp.c.

References switch_rtp::eff_remote_host_str, switch_rtp::flags, switch_rtp::pool, switch_rtp::remote_rtcp_port, switch_rtp::rtcp_local_addr, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_sock_input, switch_rtp::rtcp_sock_output, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_get_addr(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_RTP_FLAG_ENABLE_RTCP, switch_sockaddr_get_family(), switch_sockaddr_info_get(), switch_socket_close(), switch_socket_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_UNSPEC.

Referenced by switch_rtp_activate_rtcp(), and switch_rtp_set_remote_address().

                                                                                              {
        
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {

                if (switch_sockaddr_info_get(&rtp_session->rtcp_remote_addr, rtp_session->eff_remote_host_str, SWITCH_UNSPEC, 
                                                                         rtp_session->remote_rtcp_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->rtcp_remote_addr) {
                        *err = "RTCP Remote Address Error!";
                        return SWITCH_STATUS_FALSE;
                } else {
                        const char *host;
                        char bufa[50];
                        
                        host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtcp_remote_addr);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, 
                                                          "Setting RTCP remote addr to %s:%d %d\n", host, rtp_session->remote_rtcp_port, rtp_session->rtcp_remote_addr->family);
                }

                if (rtp_session->rtcp_sock_input && switch_sockaddr_get_family(rtp_session->rtcp_remote_addr) == 
                        switch_sockaddr_get_family(rtp_session->rtcp_local_addr)) {
                        rtp_session->rtcp_sock_output = rtp_session->rtcp_sock_input;
                } else {

                        if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input) {
                                switch_socket_close(rtp_session->rtcp_sock_output);
                        }

                        if ((status = switch_socket_create(&rtp_session->rtcp_sock_output,
                                                                                           switch_sockaddr_get_family(rtp_session->rtcp_remote_addr),
                                                                                           SOCK_DGRAM, 0, rtp_session->pool)) != SWITCH_STATUS_SUCCESS) {
                                *err = "RTCP Socket Error!";
                        }
                }

        } else {
                *err = "RTCP NOT ACTIVE!";
        }
        
        return status;
        
}

static void free_dtls ( switch_dtls_t **  dtlsp )

static

Definition at line 3124 of file switch_rtp.c.

References switch_dtls_s::ssl, and switch_dtls_s::ssl_ctx.

Referenced by switch_rtp_del_dtls(), and switch_rtp_destroy().

{
        switch_dtls_t *dtls;

        if (!dtlsp) {
                return;
        }

        dtls = *dtlsp;
        *dtlsp = NULL;

        if (dtls->ssl) {
                SSL_free(dtls->ssl);
        }

        if (dtls->ssl_ctx) {
                SSL_CTX_free(dtls->ssl_ctx);
        }
}

static uint8_t get_next_write_ts ( switch_rtp_t *  rtp_session, uint32_t  timestamp  )

static

Definition at line 1490 of file switch_rtp.c.

References switch_rtp::last_write_ts, RTP_BUG_NEVER_SEND_MARKER, RTP_BUG_SEND_LINEAR_TIMESTAMPS, switch_rtp::rtp_bugs, switch_timer::samplecount, switch_rtp::samples_per_interval, SWITCH_RTP_FLAG_USE_TIMER, switch_rtp_test_flag(), switch_rtp::timer, and switch_rtp::ts.

Referenced by check_rtcp_and_ice(), and rtp_common_write().

{
        uint8_t m = 0;

        if (rtp_session->rtp_bugs & RTP_BUG_SEND_LINEAR_TIMESTAMPS) {
                rtp_session->ts += rtp_session->samples_per_interval;
                if (rtp_session->ts <= rtp_session->last_write_ts && rtp_session->ts > 0) {
                        rtp_session->ts = rtp_session->last_write_ts + rtp_session->samples_per_interval;
                }
        } else if (timestamp) {
                rtp_session->ts = (uint32_t) timestamp;
                /* Send marker bit if timestamp is lower/same as before (resetted/new timer) */
                if (rtp_session->ts <= rtp_session->last_write_ts && !(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
                        m++;
                }
        } else if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
                rtp_session->ts = rtp_session->timer.samplecount;

                if (rtp_session->ts <= rtp_session->last_write_ts && rtp_session->ts > 0) {
                        rtp_session->ts = rtp_session->last_write_ts + rtp_session->samples_per_interval;
                }
        } else {
                rtp_session->ts += rtp_session->samples_per_interval;
                if (rtp_session->ts <= rtp_session->last_write_ts && rtp_session->ts > 0) {
                        rtp_session->ts = rtp_session->last_write_ts + rtp_session->samples_per_interval;
                }               
        }

        return m;
}

static int get_recv_payload ( switch_rtp_t *  rtp_session )

static

Definition at line 5110 of file switch_rtp.c.

References payload_map_s::allocated, switch_rtp::flag_mutex, payload_map_s::negotiated, payload_map_s::next, switch_rtp::pmaps, payload_map_s::pt, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by read_rtp_packet().

{
        int r = -1;

        if (rtp_session->pmaps && *rtp_session->pmaps) {
                payload_map_t *pmap;

                switch_mutex_lock(rtp_session->flag_mutex);

                for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {                                  
                        if (pmap->negotiated) {
                                r = pmap->pt;
                                break;
                        }
                }
                switch_mutex_unlock(rtp_session->flag_mutex);
        }

        return r;
}

static void handle_ice ( switch_rtp_t *  rtp_session, switch_rtp_ice_t *  ice, void *  data, switch_size_t  len  )

static

Definition at line 865 of file switch_rtp.c.

References switch_rtp_ice_t::addr, switch_rtp::auto_adj_used, buf, ice_s::cand_idx, icand_s::cand_type, ice_s::cands, ice_s::chosen, switch_stun_error_code_t::code, icand_s::con_addr, icand_s::con_port, DS_READY, switch_rtp::dtls, switch_rtp::first_stun, switch_rtp::flags, switch_core_session_message::from, switch_rtp::from_addr, switch_stun_packet_t::header, switch_rtp::ice, switch_rtp::ice_adj, ICE_CONTROLLED, ICE_GOOGLE_JINGLE, switch_rtp::ice_mutex, switch_rtp_ice_t::ice_params, switch_rtp_ice_t::ice_user, ICE_VANILLA, icecmp(), switch_stun_packet_header_t::id, IPR_RTP, switch_rtp_ice_t::last_ok, switch_rtp_ice_t::last_sent_id, switch_rtp::last_stun, switch_stun_packet_header_t::length, memset(), switch_core_session_message::message_id, switch_rtp_ice_t::missed_count, switch_stun_error_code_t::number, switch_core_session_message::numeric_arg, switch_rtp_ice_t::pass, switch_core_session_message::pointer_arg, switch_rtp::pool, icand_s::priority, switch_rtp_ice_t::proto, READ_DEC, READ_INC, switch_rtp_ice_t::ready, switch_stun_error_code_t::reason, switch_rtp::remote_addr, switch_rtp::remote_port, switch_rtp_ice_t::rready, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_ice, switch_rtp::rtcp_sock_output, RTP_BUG_ALWAYS_AUTO_ADJUST, switch_rtp::rtp_bugs, rtp_session_name, rtp_type, switch_rtp::session, switch_rtp::sock_output, switch_dtls_s::state, switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_cmp_addr(), switch_core_session_get_channel(), switch_core_session_receive_message, switch_core_session_video_reinit(), SWITCH_FALSE, switch_get_addr(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG4, SWITCH_LOG_DEBUG8, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MESSAGE_INDICATE_STUN_ERROR, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_change_ice_dest(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_AUTOADJ, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_VIDEO, switch_rtp_ready(), switch_rtp_set_flag(), switch_rtp_set_remote_address(), switch_snprintf(), switch_sockaddr_get_port(), switch_sockaddr_info_get(), switch_socket_sendto(), SWITCH_STATUS_SUCCESS, SWITCH_STUN_ATTR_ERROR_CODE, SWITCH_STUN_ATTR_MAPPED_ADDRESS, SWITCH_STUN_ATTR_PRIORITY, SWITCH_STUN_ATTR_USE_CAND, SWITCH_STUN_ATTR_USERNAME, SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS, switch_stun_attribute_padded_length, SWITCH_STUN_BINDING_ERROR_RESPONSE, SWITCH_STUN_BINDING_REQUEST, SWITCH_STUN_BINDING_RESPONSE, switch_stun_packet_attribute_add_fingerprint(), switch_stun_packet_attribute_add_integrity(), switch_stun_packet_attribute_add_username(), switch_stun_packet_attribute_add_xor_binded_address(), switch_stun_packet_attribute_get_mapped_address(), switch_stun_packet_attribute_get_username(), switch_stun_packet_attribute_get_xor_mapped_address(), switch_stun_packet_build_header(), switch_stun_packet_first_attribute, switch_stun_packet_length, switch_stun_packet_next_attribute, switch_stun_packet_parse(), SWITCH_STUN_TYPE_ATTRIBUTE, SWITCH_STUN_TYPE_PACKET_TYPE, switch_stun_value_to_name(), SWITCH_UNSPEC, switch_stun_packet_header_t::type, switch_stun_packet_attribute_t::type, switch_rtp_ice_t::type, switch_rtp_ice_t::user_ice, switch_stun_packet_attribute_t::value, WRITE_DEC, WRITE_INC, switch_rtp::wrong_addrs, and zstr.

Referenced by process_rtcp_packet(), read_rtcp_packet(), and read_rtp_packet().

{
        switch_stun_packet_t *packet;
        switch_stun_packet_attribute_t *attr;
        void *end_buf;
        char username[34] = { 0 };
        unsigned char buf[512] = { 0 };
        switch_size_t cpylen = len;
        int xlen = 0;
        int ok = 1;
        uint32_t *pri = NULL;
        int is_rtcp = ice == &rtp_session->rtcp_ice;
        uint32_t elapsed;
        switch_time_t ref_point;
                                
        //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
        //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF OK %s CALL\n", rtp_type(rtp_session));
        //}

        if (!switch_rtp_ready(rtp_session) || zstr(ice->user_ice) || zstr(ice->ice_user)) {
                return;
        }

        switch_mutex_lock(rtp_session->ice_mutex);

        READ_INC(rtp_session);
        WRITE_INC(rtp_session);

        if (!switch_rtp_ready(rtp_session)) {
                goto end;
        }

        if (cpylen > sizeof(buf)) {
                cpylen = sizeof(buf);
        }

        
        memcpy(buf, data, cpylen);
        packet = switch_stun_packet_parse(buf, (uint32_t)cpylen);
        if (!packet) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Invalid STUN/ICE packet received %ld bytes\n", (long)cpylen);
                goto end;

        }

        rtp_session->last_stun = switch_micro_time_now();

        if (!rtp_session->first_stun) {
                rtp_session->first_stun = rtp_session->last_stun;
        }
        
        if (ice->last_ok) {
                ref_point = ice->last_ok;
        } else {
                ref_point = rtp_session->first_stun;
        } 
        
        elapsed = (unsigned int) ((switch_micro_time_now() - ref_point) / 1000);


        end_buf = buf + ((sizeof(buf) > packet->header.length) ? packet->header.length : sizeof(buf));

        switch_stun_packet_first_attribute(packet, attr);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "%s STUN PACKET TYPE: %s\n", 
                                          rtp_type(rtp_session), switch_stun_value_to_name(SWITCH_STUN_TYPE_PACKET_TYPE, packet->header.type));
        do {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "|---: %s STUN ATTR %d %x %s\n", rtp_type(rtp_session), attr->type, attr->type,
                                                  switch_stun_value_to_name(SWITCH_STUN_TYPE_ATTRIBUTE, attr->type));

                switch (attr->type) {
                case SWITCH_STUN_ATTR_USE_CAND:
                        {
                                ice->rready = 1;
                        }
                        break;
                case SWITCH_STUN_ATTR_ERROR_CODE:
                        {
                                switch_stun_error_code_t *err = (switch_stun_error_code_t *) attr->value;
                                uint32_t code = (err->code * 100) + err->number;

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "%s got %s stun binding response %u %s\n",
                                                                  rtp_session_name(rtp_session),
                                                                  rtp_type(rtp_session),
                                                                  code,
                                                                  err->reason
                                                                  );

                                if ((ice->type & ICE_VANILLA) && code == 487) {
                                        if ((ice->type & ICE_CONTROLLED)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "%s STUN Changing role to CONTROLLING\n", rtp_type(rtp_session));
                                                ice->type &= ~ICE_CONTROLLED;
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "%s STUN Changing role to CONTROLLED\n", rtp_type(rtp_session));
                                                ice->type |= ICE_CONTROLLED;
                                        }
                                        packet->header.type = SWITCH_STUN_BINDING_RESPONSE;
                                }

                        }
                        break;
                case SWITCH_STUN_ATTR_MAPPED_ADDRESS:
                        if (attr->type) {
                                char ip[50];
                                uint16_t port;
                                switch_stun_packet_attribute_get_mapped_address(attr, ip, sizeof(ip), &port);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s:%d\n", ip, port);
                        }
                        break;
                case SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS:
                        if (attr->type) {
                                char ip[50];
                                uint16_t port;
                                switch_stun_packet_attribute_get_xor_mapped_address(attr, &packet->header, ip, sizeof(ip), &port);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s:%d\n", ip, port);
                        }
                        break;
                case SWITCH_STUN_ATTR_USERNAME:
                        if (attr->type) {
                                switch_stun_packet_attribute_get_username(attr, username, sizeof(username));
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s\n", username);
                        }
                        break;
                        
                case SWITCH_STUN_ATTR_PRIORITY:
                        {
                                uint32_t priority = 0;
                                pri = (uint32_t *) attr->value;
                                priority = ntohl(*pri);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %u\n", priority);
                                ok = priority == ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].priority;
                        }
                        break;
                }

                if (!switch_stun_packet_next_attribute(attr, end_buf)) {
                        break;
                }

                xlen += 4 + switch_stun_attribute_padded_length(attr);
        } while (xlen <= packet->header.length);

        if ((ice->type & ICE_GOOGLE_JINGLE) && ok) {
                ok = !strcmp(ice->user_ice, username);
        }

        if (packet->header.type != SWITCH_STUN_BINDING_REQUEST && packet->header.type != SWITCH_STUN_BINDING_RESPONSE) {
                goto end;
        }
        
        if ((ice->type & ICE_VANILLA)) {
                char foo1[13] = "", foo2[13] = "";
                if (!ok) ok = !memcmp(packet->header.id, ice->last_sent_id, 12);

                if (packet->header.type == SWITCH_STUN_BINDING_RESPONSE) {
                        ok = 1;
                        if (!ice->rready) {
                                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                                        rtp_session->ice.rready = 1;
                                        rtp_session->rtcp_ice.rready = 1;
                                } else {
                                        ice->rready = 1;
                                }
                                
                                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                                        switch_core_session_video_reinit(rtp_session->session);
                                }
                        }
                }

                memcpy(foo1, packet->header.id, 12);
                memcpy(foo2, ice->last_sent_id, 12);

                if (!ok && ice == &rtp_session->ice && rtp_session->rtcp_ice.ice_params && pri && 
                        *pri == rtp_session->rtcp_ice.ice_params->cands[rtp_session->rtcp_ice.ice_params->chosen[1]][1].priority) {
                        ice = &rtp_session->rtcp_ice;
                        ok = 1;
                }

                if (!zstr(username)) {
                        if (!icecmp(username, ice)) {
                                ok = 1;
                        } else if(!zstr(rtp_session->rtcp_ice.user_ice) && !icecmp(username, &rtp_session->rtcp_ice)) {
                                ice = &rtp_session->rtcp_ice;
                                ok = 1;
                        }
                }

                if (ok) {
                        ice->missed_count = 0;
                } else {
                        switch_rtp_ice_t *icep[2] = { &rtp_session->ice, &rtp_session->rtcp_ice };
                        switch_port_t port = 0;
                        char *host = NULL;

                        if (elapsed > 20000 && pri) {
                                int i, j;
                                uint32_t old;
                                //const char *tx_host;
                                const char *old_host, *err = NULL;
                                //char bufa[50];
                                char bufb[50];
                                char adj_port[6];
                                switch_channel_t *channel = NULL;
                                

                                ice->missed_count++;
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "missed %d\n", ice->missed_count);


                                if (rtp_session->session) {
                                        channel = switch_core_session_get_channel(rtp_session->session);
                                }

                                //ice->ice_params->cands[ice->ice_params->chosen][ice->proto].priority;
                                for (j = 0; j < 2; j++) {
                                        if (!icep[j] || !icep[j]->ice_params) {
                                                continue;
                                        }
                                        for (i = 0; i < icep[j]->ice_params->cand_idx[icep[j]->proto]; i++) {
                                                if (icep[j]->ice_params &&  icep[j]->ice_params->cands[i][icep[j]->proto].priority == *pri) {
                                                        if (j == IPR_RTP) {
                                                                icep[j]->ice_params->chosen[j] = i;
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Change candidate index to %d\n", i);
                                                        }

                                                        ice = icep[j];
                                                        ok = 1;
                                                        
                                                        if (j != IPR_RTP) {
                                                                break;
                                                        }

                                                        old = rtp_session->remote_port;
                                                        
                                                        //tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr);
                                                        old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
                                                        
                                                        host = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr;
                                                        port = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port;

                                                        if (!host || !port) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
                                                                return;                                                         
                                                        }
                                                        
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO,
                                                                                          "%s ICE Auto Changing port from %s:%u to %s:%u\n", rtp_type(rtp_session), old_host, old, host, port);

                                                        
                                                        if (channel) {
                                                                switch_channel_set_variable(channel, "remote_media_ip_reported", switch_channel_get_variable(channel, "remote_media_ip"));
                                                                switch_channel_set_variable(channel, "remote_media_ip", host);
                                                                switch_channel_set_variable(channel, "rtp_auto_adjust_ip", host);
                                                                switch_snprintf(adj_port, sizeof(adj_port), "%u", port);
                                                                switch_channel_set_variable(channel, "remote_media_port_reported", switch_channel_get_variable(channel, "remote_media_port"));
                                                                switch_channel_set_variable(channel, "remote_media_port", adj_port);
                                                                switch_channel_set_variable(channel, "rtp_auto_adjust_port", adj_port);
                                                                switch_channel_set_variable(channel, "rtp_auto_candidate_adjust", "true");
                                                        }
                                                        rtp_session->auto_adj_used = 1;

                                                        
                                                        switch_rtp_set_remote_address(rtp_session, host, port, 0, SWITCH_FALSE, &err);
                                                        if (switch_sockaddr_info_get(&ice->addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || 
                                                                !ice->addr) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
                                                                return;
                                                        }
                                                        
                                                        if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
                                                                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                                        } else {
                                                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                                        }
                                                        
                                                }
                                        }
                                }
                        }
                }
        }

        if (ice->missed_count > 5 && !(ice->type & ICE_GOOGLE_JINGLE)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "missed too many: %d, looking for new ICE dest.\n", 
                                                  ice->missed_count);
                ice->rready = 0;
                ok = 1;
        }


        //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] || 1) {
        //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF OK %s %d\n", rtp_type(rtp_session), ok);
        //}
        
        if (ok) {
                const char *host = NULL, *host2 = NULL;
                switch_port_t port = 0, port2 = 0;
                char buf[80] = "";
                char buf2[80] = "";

                if (packet->header.type == SWITCH_STUN_BINDING_REQUEST) {
                        uint8_t stunbuf[512];
                        switch_stun_packet_t *rpacket;
                        const char *remote_ip;
                        switch_size_t bytes;
                        char ipbuf[50];
                        switch_sockaddr_t *from_addr = rtp_session->from_addr;
                        switch_socket_t *sock_output = rtp_session->sock_output;
                        uint8_t do_adj = 0;
                        switch_time_t now = switch_micro_time_now();
                        int cmp = 0;

                        if (is_rtcp) {
                                from_addr = rtp_session->rtcp_from_addr;
                                sock_output = rtp_session->rtcp_sock_output;
                        }

                        if (!ice->ready) {
                                ice->ready = 1;
                        }

                        memset(stunbuf, 0, sizeof(stunbuf));
                        rpacket = switch_stun_packet_build_header(SWITCH_STUN_BINDING_RESPONSE, packet->header.id, stunbuf);

                        if ((ice->type & ICE_GOOGLE_JINGLE)) {
                                switch_stun_packet_attribute_add_username(rpacket, username, (uint16_t)strlen(username));
                        }

                        remote_ip = switch_get_addr(ipbuf, sizeof(ipbuf), from_addr);

                        switch_stun_packet_attribute_add_xor_binded_address(rpacket, (char *) remote_ip, switch_sockaddr_get_port(from_addr), from_addr->family);

                        if ((ice->type & ICE_VANILLA)) {
                                switch_stun_packet_attribute_add_integrity(rpacket, ice->pass);
                                switch_stun_packet_attribute_add_fingerprint(rpacket);
                        }

                        bytes = switch_stun_packet_length(rpacket);

                        host = switch_get_addr(buf, sizeof(buf), from_addr);
                        port = switch_sockaddr_get_port(from_addr);
                        host2 = switch_get_addr(buf2, sizeof(buf2), ice->addr);
                        port2 = switch_sockaddr_get_port(ice->addr);
                        cmp = switch_cmp_addr(from_addr, ice->addr);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG4, 
                                                          "STUN from %s:%d %s\n", host, port, cmp ? "EXPECTED" : "IGNORED");

                        if (cmp) {
                                ice->last_ok = now;
                                rtp_session->wrong_addrs = 0;
                        } else {
                                if (((rtp_session->dtls && rtp_session->dtls->state != DS_READY) || !ice->ready || !ice->rready) &&
                                        rtp_session->wrong_addrs > 2 && rtp_session->ice_adj == 0) {
                                        do_adj++;
                                        rtp_session->ice_adj = 1;
                                        rtp_session->wrong_addrs = 0;
                                } else if (rtp_session->wrong_addrs > 10 || elapsed >= 10000) {
                                        do_adj++;
                                }

                                if (!do_adj) {
                                        rtp_session->wrong_addrs++;
                                }
                        }

                        if ((ice->type & ICE_VANILLA) && ice->ice_params && do_adj) {
                                int i = 0;

                                ice->missed_count = 0;
                                ice->rready = 1;

                                for (i = 0; i <= ice->ice_params->cand_idx[ice->proto]; i++) {
                                        if (ice->ice_params->cands[i][ice->proto].con_port == port) {
                                                if (!strcmp(ice->ice_params->cands[i][ice->proto].con_addr, host) && 
                                                        !strcmp(ice->ice_params->cands[i][ice->proto].cand_type, "relay")) {
                                                        
                                                        if (elapsed < 1000) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING,
                                                                                                  "Skiping RELAY stun/%s/dtls port change from %s:%u to %s:%u\n", is_rtcp ? "rtcp" : "rtp", 
                                                                                                  host2, port2,
                                                                                                  host, port);
                                                        
                                                                goto end;
                                                        }

                                                        break;
                                                }
                                        }
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_NOTICE,
                                                                  "Auto Changing %s stun/%s/dtls port from %s:%u to %s:%u\n", rtp_type(rtp_session), is_rtcp ? "rtcp" : "rtp", 
                                                                  host2, port2,
                                                                  host, port);

                                switch_rtp_change_ice_dest(rtp_session, ice, host, port);
                                ice->last_ok = now;
                                rtp_session->wrong_addrs = 0;
                        }
                        if (cmp) {
                                switch_socket_sendto(sock_output, from_addr, 0, (void *) rpacket, &bytes);
                        }
                }
        } else if (packet->header.type == SWITCH_STUN_BINDING_ERROR_RESPONSE) {
                
                if (rtp_session->session) {
                        switch_core_session_message_t msg = { 0 };
                        msg.from = __FILE__;
                        msg.numeric_arg = packet->header.type;
                        msg.pointer_arg = packet;
                        msg.message_id = SWITCH_MESSAGE_INDICATE_STUN_ERROR;
                        switch_core_session_receive_message(rtp_session->session, &msg);                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, 
                                                          "STUN/ICE binding error received on %s channel\n", rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio");
                }

        }




 end:
        switch_mutex_unlock(rtp_session->ice_mutex);
        READ_DEC(rtp_session);
        WRITE_DEC(rtp_session);
}

static void handle_nack ( switch_rtp_t *  rtp_session, uint32_t  nack  )

static

Definition at line 5763 of file switch_rtp.c.

References switch_rtp::flags, rtp_msg_t::header, switch_rtp::local_addr, switch_rtp::remote_addr, switch_rtp::remote_port, switch_rtp::rtcp_from_addr, switch_rtp::session, switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, SWITCH_CHANNEL_SESSION_LOG_CLEAN, switch_core_media_gen_key_frame, switch_core_session_get_channel(), SWITCH_FALSE, switch_get_addr(), switch_jb_get_packet_by_seq(), SWITCH_LOG_CONSOLE, SWITCH_LOG_DEBUG1, switch_log_printf(), SWITCH_RTP_FLAG_DEBUG_RTP_WRITE, SWITCH_RTP_FLAG_NACK, switch_rtp_write_raw(), switch_sockaddr_get_port(), SWITCH_STATUS_SUCCESS, and switch_rtp::vbw.

Referenced by process_rtcp_report().

{
        switch_size_t bytes = 0;
        rtp_msg_t send_msg[1] = {{{0}}};
        uint16_t seq = (uint16_t) (nack & 0xFFFF);
        uint16_t blp = (uint16_t) (nack >> 16);
        int i;
        const char *tx_host = NULL;
        const char *old_host = NULL;
        const char *my_host = NULL;
        char bufa[50], bufb[50], bufc[50];

        if (!(rtp_session->flags[SWITCH_RTP_FLAG_NACK] && rtp_session->vbw)) {
                return;  /* not enabled */
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtcp_from_addr);
                old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
                my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Got NACK [%u][0x%x] for seq %u\n", nack, nack, ntohs(seq));
        
        if (switch_jb_get_packet_by_seq(rtp_session->vbw, seq, (switch_rtp_packet_t *) send_msg, &bytes) == SWITCH_STATUS_SUCCESS) {

                if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_CONSOLE,
                                                          "X %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
                                                          rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
                                                          (long) bytes,
                                                          my_host, switch_sockaddr_get_port(rtp_session->local_addr),
                                                          old_host, rtp_session->remote_port,
                                                          tx_host, switch_sockaddr_get_port(rtp_session->rtcp_from_addr),
                                                          send_msg->header.pt, ntohl(send_msg->header.ts), ntohs(send_msg->header.seq), send_msg->header.m);

                }
                //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "RE----SEND %u\n", ntohs(send_msg->header.seq));
                switch_rtp_write_raw(rtp_session, (void *) send_msg, &bytes, SWITCH_FALSE);
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Cannot send NACK for seq %u\n", ntohs(seq));
        }

        blp = ntohs(blp);
        for (i = 0; i < 16; i++) {
                if (blp & (1 << i)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Also Got NACK for seq %u\n", ntohs(seq) + i + 1);
                        /* If they are missing more than one, may as well gen a key frame for good measure */
                        switch_core_media_gen_key_frame(rtp_session->session);
                        if (switch_jb_get_packet_by_seq(rtp_session->vbw, htons(ntohs(seq) + i + 1), (switch_rtp_packet_t *) &send_msg, &bytes) == SWITCH_STATUS_SUCCESS) {
                                if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_CONSOLE,
                                                                          "X %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
                                                                          rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
                                                                          (long) bytes,
                                                                          my_host, switch_sockaddr_get_port(rtp_session->local_addr),
                                                                          old_host, rtp_session->remote_port,
                                                                          tx_host, switch_sockaddr_get_port(rtp_session->rtcp_from_addr),
                                                                          send_msg->header.pt, ntohl(send_msg->header.ts), ntohs(send_msg->header.seq), send_msg->header.m);
                                        
                                }
                                //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "RE----SEND %u\n", ntohs(send_msg->header.seq));
                                switch_rtp_write_raw(rtp_session, (void *) &send_msg, &bytes, SWITCH_FALSE);
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Cannot send NACK for seq %u\n", ntohs(seq) + i);
                        }
                }
        }
}

static handle_rfc2833_result_t handle_rfc2833 ( switch_rtp_t *  rtp_session, switch_size_t  bytes, int *  do_cng  )

static

Definition at line 539 of file switch_rtp.c.

References switch_dtmf_t::digit, switch_rtp::dtmf_data, DTMF_SANITY, switch_dtmf_t::duration, switch_rtp_rfc2833_data::first_digit, switch_rtp::flags, switch_rtp_rfc2833_data::flip, switch_rtp_rfc2833_data::in_digit_queued, switch_rtp_rfc2833_data::in_digit_sanity, switch_rtp_rfc2833_data::in_digit_seq, switch_rtp_rfc2833_data::in_digit_ts, switch_rtp_rfc2833_data::in_interleaved, switch_rtp_stats_t::inbound, switch_rtp::jb, switch_rtp_rfc2833_data::last_digit, switch_rtp_rfc2833_data::last_duration, switch_rtp_rfc2833_data::last_in_digit_ts, switch_rtp_numbers_t::last_processed_seq, switch_rtp::last_rtp_hdr, switch_rtp::pool, switch_rtp::recv_te, RESULT_CONTINUE, RESULT_GOTO_END, RESULT_GOTO_RECVFROM, RESULT_GOTO_TIMERCHECK, RTP_BODY, RTP_BUG_FLUSH_JB_ON_DTMF, RTP_BUG_IGNORE_DTMF_DURATION, switch_rtp::rtp_bugs, rtp_header_len, switch_rtp::session, switch_rtp::stats, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, switch_cond_next(), switch_core_memory_pool_get_data(), switch_core_min_dtmf_duration(), SWITCH_DTMF_RTP, switch_jb_reset(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_rfc2833_to_char(), SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_PASS_RFC2833, SWITCH_RTP_FLAG_PROXY_MEDIA, switch_rtp_queue_rfc2833_in(), and switch_rtp_ready().

Referenced by do_flush(), and rtp_common_read().

{

        if (rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]) {
                rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]++;

                if (rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] > DTMF_SANITY) {
                        rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = 0;
                } else {
                        rtp_session->stats.inbound.last_processed_seq = 0;
                }
        }


#ifdef DEBUG_2833
        if (rtp_session->dtmf_data.in_digit_sanity && !(rtp_session->dtmf_data.in_digit_sanity % 100)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "sanity %d %ld\n", rtp_session->dtmf_data.in_digit_sanity, bytes);
        }
#endif

        if (rtp_session->dtmf_data.in_digit_sanity && !--rtp_session->dtmf_data.in_digit_sanity) {
                
                rtp_session->dtmf_data.last_digit = 0;
                rtp_session->dtmf_data.in_digit_ts = 0;
                rtp_session->dtmf_data.in_digit_queued = 0;
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Failed DTMF sanity check.\n");
        }

        /* RFC2833 ... like all RFC RE: VoIP, guaranteed to drive you to insanity! 
           We know the real rules here, but if we enforce them, it's an interop nightmare so,
           we put up with as much as we can so we don't have to deal with being punished for
           doing it right. Nice guys finish last!
        */
        
        if (bytes > rtp_header_len && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] &&
                rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
                switch_size_t len = bytes - rtp_header_len;
                unsigned char *packet = (unsigned char *) RTP_BODY(rtp_session);
                int end;
                uint16_t duration;
                char key;
                uint16_t in_digit_seq;
                uint32_t ts;

                rtp_session->stats.inbound.last_processed_seq = 0;

                if (!(packet[0] || packet[1] || packet[2] || packet[3]) && len >= 8) {
                        packet += 4;
                        len -= 4;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "DTMF payload offset by 4 bytes.\n");
                }

                if (!(packet[0] || packet[1] || packet[2] || packet[3]) && rtp_session->dtmf_data.in_digit_ts) {
                        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Failed DTMF payload check.\n");
                        rtp_session->dtmf_data.last_digit = 0;
                        rtp_session->dtmf_data.in_digit_ts = 0;
                        rtp_session->dtmf_data.in_digit_sanity = 0;
                        rtp_session->dtmf_data.in_digit_queued = 0;
                }

                end = packet[1] & 0x80 ? 1 : 0;
                duration = (packet[2] << 8) + packet[3];
                key = switch_rfc2833_to_char(packet[0]);
                in_digit_seq = ntohs((uint16_t) rtp_session->last_rtp_hdr.seq);
                ts = htonl(rtp_session->last_rtp_hdr.ts);

                if (rtp_session->flags[SWITCH_RTP_FLAG_PASS_RFC2833]) {

                        if (end) {
                                rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = DTMF_SANITY - 3;
                        } else if (!rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]) {
                                rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = 1;
                        }

                        return RESULT_CONTINUE;
                }

                if (in_digit_seq < rtp_session->dtmf_data.in_digit_seq) {
                        if (rtp_session->dtmf_data.in_digit_seq - in_digit_seq > 100) {
                                rtp_session->dtmf_data.in_digit_seq = 0;
                        }
                }
#ifdef DEBUG_2833
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "packet[%d]: %02x %02x %02x %02x\n", (int) len, (unsigned char) packet[0], (unsigned char) packet[1], (unsigned char) packet[2], (unsigned char) packet[3]);
#endif

                if (in_digit_seq > rtp_session->dtmf_data.in_digit_seq) {

                        rtp_session->dtmf_data.in_digit_seq = in_digit_seq;
#ifdef DEBUG_2833

                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "read: %c %u %u %u %u %d %d %s\n",
                                                          key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq,
                                   ts, duration, rtp_session->last_rtp_hdr.m, end, end && !rtp_session->dtmf_data.in_digit_ts ? "ignored" : "");
#endif


                        if (rtp_session->dtmf_data.in_digit_ts && rtp_session->dtmf_data.in_digit_ts != ts) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "TS changed from last packet, resetting....\n");
                                rtp_session->dtmf_data.last_digit = 0;
                                rtp_session->dtmf_data.in_digit_ts = 0;
                                rtp_session->dtmf_data.in_digit_sanity = 0;
                                rtp_session->dtmf_data.in_digit_queued = 0;
                        }


                        if (!rtp_session->dtmf_data.in_digit_queued && rtp_session->dtmf_data.in_digit_ts) {
                                if ((rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION)) {
                                        switch_dtmf_t dtmf = { key, switch_core_min_dtmf_duration(0), 0, SWITCH_DTMF_RTP };
#ifdef DEBUG_2833
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Early Queuing digit %c:%d\n", dtmf.digit, dtmf.duration / 8);
#endif
                                        switch_rtp_queue_rfc2833_in(rtp_session, &dtmf);
                                        rtp_session->dtmf_data.in_digit_queued = 1;
                                }

                                if (rtp_session->jb && (rtp_session->rtp_bugs & RTP_BUG_FLUSH_JB_ON_DTMF)) {
                                        switch_jb_reset(rtp_session->jb);
                                }
                                
                        }

                        /* only set sanity if we do NOT ignore the packet */
                        if (rtp_session->dtmf_data.in_digit_ts) {
                                rtp_session->dtmf_data.in_digit_sanity = 2000;
                        }

                        if (rtp_session->dtmf_data.last_duration > duration && 
                                rtp_session->dtmf_data.last_duration > 0xFC17 && ts == rtp_session->dtmf_data.in_digit_ts) {
                                rtp_session->dtmf_data.flip++;
                        }

                        if (end) {
                                if (!rtp_session->dtmf_data.in_digit_ts && rtp_session->dtmf_data.last_in_digit_ts != ts) {
#ifdef DEBUG_2833
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "start with end packet %d\n", ts);
#endif
                                        rtp_session->dtmf_data.last_in_digit_ts = ts;
                                        rtp_session->dtmf_data.in_digit_ts = ts;
                                        rtp_session->dtmf_data.first_digit = key;
                                        rtp_session->dtmf_data.in_digit_sanity = 2000;
                                }
                                if (rtp_session->dtmf_data.in_digit_ts) {
                                        switch_dtmf_t dtmf = { key, duration, 0, SWITCH_DTMF_RTP };

                                        if (ts > rtp_session->dtmf_data.in_digit_ts) {
                                                dtmf.duration += (ts - rtp_session->dtmf_data.in_digit_ts);
                                        }
                                        if (rtp_session->dtmf_data.flip) {
                                                dtmf.duration += rtp_session->dtmf_data.flip * 0xFFFF;
                                                rtp_session->dtmf_data.flip = 0;
#ifdef DEBUG_2833
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "you're welcome!\n");
#endif
                                        }
#ifdef DEBUG_2833
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "done digit=%c ts=%u start_ts=%u dur=%u ddur=%u\n",
                                                   dtmf.digit, ts, rtp_session->dtmf_data.in_digit_ts, duration, dtmf.duration);
#endif
                                                
                                        if (!(rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION) && !rtp_session->dtmf_data.in_digit_queued) {
#ifdef DEBUG_2833
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Queuing digit %c:%d\n", dtmf.digit, dtmf.duration / 8);
#endif
                                                switch_rtp_queue_rfc2833_in(rtp_session, &dtmf);
                                        }

                                        rtp_session->dtmf_data.last_digit = rtp_session->dtmf_data.first_digit;

                                        rtp_session->dtmf_data.in_digit_ts = 0;
                                        rtp_session->dtmf_data.in_digit_sanity = 0;
                                        rtp_session->dtmf_data.in_digit_queued = 0;
                                        *do_cng = 1;
                                } else {
                                        if (!switch_rtp_ready(rtp_session)) {
                                                return RESULT_GOTO_END;
                                        }
                                        switch_cond_next();
                                        return RESULT_GOTO_RECVFROM;
                                }

                        } else if (!rtp_session->dtmf_data.in_digit_ts) {
#ifdef DEBUG_2833
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "start %d [%c]\n", ts, key);
#endif
                                rtp_session->dtmf_data.in_digit_ts = ts;
                                rtp_session->dtmf_data.last_in_digit_ts = ts;
                                rtp_session->dtmf_data.first_digit = key;
                                rtp_session->dtmf_data.in_digit_sanity = 2000;
                        }

                        rtp_session->dtmf_data.last_duration = duration;
                } else {
#ifdef DEBUG_2833
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "drop: %c %u %u %u %u %d %d\n",
                                   key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq, ts, duration, rtp_session->last_rtp_hdr.m, end);
#endif
                        switch_cond_next();
                        return RESULT_GOTO_RECVFROM;
                }
        }

        if (bytes && rtp_session->dtmf_data.in_digit_ts) {
                if (!switch_rtp_ready(rtp_session)) {
                        return RESULT_GOTO_END;
                }

                if (!rtp_session->dtmf_data.in_interleaved && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te) {
                        /* Drat, they are sending audio still as well as DTMF ok fine..... *sigh* */
                        rtp_session->dtmf_data.in_interleaved = 1;
                }
                        
                if (rtp_session->dtmf_data.in_interleaved || (rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION)) {
                        if (rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
                                return RESULT_GOTO_RECVFROM;
                        }
                } else {
                        *do_cng = 1;
                        return RESULT_GOTO_TIMERCHECK;
                }
        }

        return RESULT_CONTINUE;
}

static switch_status_t ice_out ( switch_rtp_t *  rtp_session, switch_rtp_ice_t *  ice  )

static

Definition at line 771 of file switch_rtp.c.

References switch_rtp_ice_t::addr, buf, ice_s::cands, ice_s::chosen, switch_stun_packet_t::header, ICE_CONTROLLED, switch_rtp_ice_t::ice_params, switch_rtp_ice_t::ice_user, ICE_VANILLA, switch_stun_packet_header_t::id, switch_rtp_ice_t::last_sent_id, switch_rtp::last_stun, switch_rtp_ice_t::next_run, icand_s::priority, switch_rtp_ice_t::proto, READ_DEC, READ_INC, switch_rtp_ice_t::rpass, switch_rtp::rtcp_ice, switch_rtp::rtcp_sock_output, rtp_session_name, RTP_STUN_FREQ, rtp_type, switch_rtp_ice_t::sending, switch_rtp::session, switch_rtp::sock_output, switch_assert, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), switch_snprintf(), switch_socket_sendto(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_STUN_BINDING_REQUEST, switch_stun_packet_attribute_add_controlled(), switch_stun_packet_attribute_add_controlling(), switch_stun_packet_attribute_add_fingerprint(), switch_stun_packet_attribute_add_integrity(), switch_stun_packet_attribute_add_priority(), switch_stun_packet_attribute_add_software(), switch_stun_packet_attribute_add_use_candidate(), switch_stun_packet_attribute_add_username(), switch_stun_packet_build_header(), switch_stun_packet_length, switch_version_revision_human(), and switch_rtp_ice_t::type.

Referenced by check_rtcp_and_ice(), generate_m(), and switch_core_media_gen_local_sdp().

{
        uint8_t buf[256] = { 0 };
        switch_stun_packet_t *packet;
        unsigned int elapsed;
        switch_size_t bytes;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        //switch_sockaddr_t *remote_addr = rtp_session->remote_addr;
        switch_socket_t *sock_output = rtp_session->sock_output;
        switch_time_t now = switch_micro_time_now();

        if (ice->next_run && ice->next_run > now) {
                return SWITCH_STATUS_BREAK;
        }

        ice->next_run = now + RTP_STUN_FREQ;
                
        if (ice == &rtp_session->rtcp_ice && rtp_session->rtcp_sock_output) {
                sock_output = rtp_session->rtcp_sock_output;            
        }

        if (!sock_output) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(rtp_session != NULL);
        switch_assert(ice->ice_user != NULL);

        READ_INC(rtp_session);

        if (rtp_session->last_stun) {
                elapsed = (unsigned int) ((switch_micro_time_now() - rtp_session->last_stun) / 1000);

                if (elapsed > 30000) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "No %s stun for a long time!\n", rtp_type(rtp_session));
                        rtp_session->last_stun = switch_micro_time_now();
                        //status = SWITCH_STATUS_GENERR;
                        //goto end;
                }
        }

        packet = switch_stun_packet_build_header(SWITCH_STUN_BINDING_REQUEST, NULL, buf);
        switch_stun_packet_attribute_add_username(packet, ice->ice_user, (uint16_t)strlen(ice->ice_user));

        memcpy(ice->last_sent_id, packet->header.id, 12);

        //if (ice->pass && ice->type == ICE_GOOGLE_JINGLE) {
        //      switch_stun_packet_attribute_add_password(packet, ice->pass, (uint16_t)strlen(ice->pass));
        //}

        if ((ice->type & ICE_VANILLA)) {
                char sw[128] = "";

                switch_stun_packet_attribute_add_priority(packet, ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].priority);

                switch_snprintf(sw, sizeof(sw), "FreeSWITCH (%s)", switch_version_revision_human());
                switch_stun_packet_attribute_add_software(packet, sw, (uint16_t)strlen(sw));

                if ((ice->type & ICE_CONTROLLED)) {
                        switch_stun_packet_attribute_add_controlled(packet);
                } else {
                        switch_stun_packet_attribute_add_controlling(packet);
                        switch_stun_packet_attribute_add_use_candidate(packet);
                }

                switch_stun_packet_attribute_add_integrity(packet, ice->rpass);
                switch_stun_packet_attribute_add_fingerprint(packet);
        }


        bytes = switch_stun_packet_length(packet);

#ifdef DEBUG_EXTRA
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "%s send %s stun\n", rtp_session_name(rtp_session), rtp_type(rtp_session));
#endif
        switch_socket_sendto(sock_output, ice->addr, 0, (void *) packet, &bytes);
                                                 
        ice->sending = 3;

        // end:
        READ_DEC(rtp_session);

        return status;
}

int icecmp	(	const char *	them,
		switch_rtp_ice_t *	ice
	)

Definition at line 856 of file switch_rtp.c.

References switch_rtp_ice_t::luser_ice, and switch_rtp_ice_t::user_ice.

Referenced by handle_ice().

{
        if (strchr(them, ':')) {
                return strcmp(them, ice->user_ice);
        }

        return strcmp(them, ice->luser_ice);
}

static int jb_valid ( switch_rtp_t *  rtp_session )

static

Definition at line 4967 of file switch_rtp.c.

References DS_READY, switch_rtp::dtls, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_rtp_ice_t::ready, switch_rtp_ice_t::rready, and switch_dtls_s::state.

Referenced by do_flush(), read_rtp_packet(), and rtp_common_read().

{
        if (rtp_session->ice.ice_user) {
                if (!rtp_session->ice.ready && rtp_session->ice.rready) {
                        return 0;
                }
        }

        if (rtp_session->dtls && rtp_session->dtls->state != DS_READY) {
                return 0;
        }

        return 1;
}

static void ping_socket ( switch_rtp_t *  rtp_session )

static

Definition at line 2832 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::local_addr, switch_rtp::rtcp_local_addr, switch_rtp::rtcp_sock_input, switch_rtp::sock_input, SWITCH_RTP_FLAG_ENABLE_RTCP, and switch_socket_sendto().

Referenced by switch_rtp_break(), switch_rtp_kill_socket(), and switch_rtp_udptl_mode().

{
        uint32_t o = UINT_MAX;
        switch_size_t len = sizeof(o);
        switch_socket_sendto(rtp_session->sock_input, rtp_session->local_addr, 0, (void *) &o, &len);

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] && rtp_session->rtcp_sock_input) {
                switch_socket_sendto(rtp_session->rtcp_sock_input, rtp_session->rtcp_local_addr, 0, (void *) &o, &len);
        }
}

static switch_status_t process_rtcp_packet ( switch_rtp_t *  rtp_session, switch_size_t *  bytes  )

static

Definition at line 5984 of file switch_rtp.c.

References handle_ice(), rtcp_msg_t::header, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_rtcp_hdr_s::length, process_rtcp_report(), switch_rtp::rtcp_ice, switch_rtp::rtcp_recv_msg_p, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_SIZE_T_FMT, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_rtcp_hdr_s::type, and switch_rtcp_hdr_s::version.

Referenced by read_rtcp_packet(), and rtp_common_read().

{
        switch_size_t len;
        switch_size_t remain = *bytes;
        switch_status_t status = SWITCH_STATUS_FALSE;
        rtcp_msg_t *msg = rtp_session->rtcp_recv_msg_p;
        
        if (msg->header.version != 2) {
                if (msg->header.version == 0) {
                        if (rtp_session->ice.ice_user) {
                                handle_ice(rtp_session, &rtp_session->rtcp_ice, (void *) msg, *bytes);
                        }
                        return SWITCH_STATUS_SUCCESS;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session),
                                                          SWITCH_LOG_WARNING, "Received an unsupported RTCP packet version %d\n", msg->header.version);
                        return SWITCH_STATUS_FALSE;
                }
        }

        do {
                len = ((switch_size_t)ntohs(msg->header.length) * 4) + 4;

                if (msg->header.version != 2 || !(msg->header.type > 199 && msg->header.type < 208)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, 
                                                          "INVALID RTCP PACKET TYPE %d VER %d LEN %" SWITCH_SIZE_T_FMT "\n", msg->header.type, 
                                                          msg->header.version, len);
                        status = SWITCH_STATUS_BREAK;
                        break;
                }

                //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, 
                //"WTF BYTES %ld REMAIN %ld PACKET TYPE %d LEN %ld\n", *bytes, remain, msg->header.type, len);

                if (len > remain) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, 
                                                          "RTCP INVALID LENGTH %" SWITCH_SIZE_T_FMT "\n", len);
                        len = remain;
                }

                status = process_rtcp_report(rtp_session, msg, len);

                if (remain > len) {
                        unsigned char *p = (unsigned char *) msg;
                        p += len;
                        msg = (rtcp_msg_t *) p;
                }

                remain -= len;

        } while (remain >= 4);

        return status;
}

static switch_status_t process_rtcp_report ( switch_rtp_t *  rtp_session, rtcp_msg_t *  msg, switch_size_t  bytes  )

static

Definition at line 5833 of file switch_rtp.c.

References _RTCP_PSFB_FIR, _RTCP_PSFB_PLI, _RTCP_PT_PSFB, _RTCP_PT_RR, _RTCP_PT_RTPFB, _RTCP_PT_SR, _RTCP_RTPFB_NACK, rtcp_ext_msg_t::body, rtcp_msg_t::body, switch_rtcp_hdr_s::count, switch_rtcp_report_block_frame::dlsr, switch_rtcp_report_block::dlsr, switch_rtp::flags, switch_rtcp_ext_hdr_t::fmt, switch_rtcp_report_block_frame::fraction, switch_rtcp_report_block::fraction, handle_nack(), rtcp_ext_msg_t::header, rtcp_msg_t::header, switch_rtcp_report_block_frame::highest_sequence_number_received, switch_rtcp_report_block::highest_sequence_number_received, if(), switch_rtcp_report_block_frame::jitter, switch_rtcp_report_block::jitter, switch_rtcp_numbers_t::last_recv_lsr_local, switch_rtcp_numbers_t::last_recv_lsr_peer, switch_rtcp_ext_hdr_t::length, switch_rtcp_hdr_s::length, switch_rtcp_report_block_frame::loss_avg, switch_rtcp_report_block_frame::lost, switch_rtcp_report_block::lost, switch_rtcp_report_block_frame::lsr, switch_rtcp_report_block::lsr, MAX_REPORT_BLOCKS, memset(), switch_rtcp_frame::ntp_lsw, switch_rtcp_sender_info::ntp_lsw, switch_rtcp_frame::ntp_msw, switch_rtcp_sender_info::ntp_msw, NTP_TIME_OFFSET, switch_rtcp_sender_info::oc, switch_rtcp_frame::octect_count, switch_rtcp_numbers_t::octet_count, switch_rtcp_hdr_s::p, switch_rtcp_frame::packet_count, switch_rtcp_numbers_t::packet_count, switch_rtcp_frame::packet_type, switch_rtcp_sender_info::pc, switch_rtcp_numbers_t::peer_ssrc, switch_rtcp_frame::report_count, switch_rtcp_frame::reports, switch_rtp_stats_t::rtcp, switch_rtp::rtcp_frame, switch_rtp::rtcp_fresh_frame, switch_rtp::rtcp_recv_msg_p, switch_rtcp_report_block_frame::rtt_avg, SCC_AUDIO_PACKET_LOSS, SCCT_INT, SCCT_NONE, switch_rtcp_sender_report::sender_info, switch_rtp::session, switch_rtcp_report_block_frame::ssrc, switch_rtcp_frame::ssrc, switch_rtcp_report_block::ssrc, switch_rtcp_sender_report::ssrc, switch_rtcp_receiver_report::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_core_media_codec_control(), switch_core_media_gen_key_frame, SWITCH_IO_WRITE, switch_jb_reset(), SWITCH_LOG_DEBUG1, SWITCH_LOG_DEBUG10, SWITCH_LOG_DEBUG3, switch_log_printf(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_RTP_FLAG_RTCP_PASSTHRU, SWITCH_RTP_FLAG_VIDEO, SWITCH_SIZE_T_FMT, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_time_exp_gmt(), switch_time_now(), switch_rtcp_frame::timestamp, switch_time_exp_t::tm_hour, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_usec, switch_time_exp_t::tm_year, switch_rtcp_sender_info::ts, switch_rtcp_hdr_s::type, and switch_rtp::vbw.

Referenced by process_rtcp_packet().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        int i;

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3,
                                          "RTCP packet bytes %" SWITCH_SIZE_T_FMT " type %d pad %d\n", 
                                          bytes, msg->header.type, msg->header.p);
        
        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (msg->header.type == _RTCP_PT_RTPFB || msg->header.type == _RTCP_PT_PSFB)) {
                rtcp_ext_msg_t *extp = (rtcp_ext_msg_t *) msg;                  

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "PICKED UP XRTCP type: %d fmt: %d\n", 
                                                  msg->header.type, extp->header.fmt);
                
                if (msg->header.type == _RTCP_PT_PSFB && (extp->header.fmt == _RTCP_PSFB_FIR || extp->header.fmt == _RTCP_PSFB_PLI)) {
                        switch_core_media_gen_key_frame(rtp_session->session);
                        if (rtp_session->vbw) {
                                switch_jb_reset(rtp_session->vbw);
                        }
                }

                if (msg->header.type == _RTCP_PT_RTPFB && extp->header.fmt == _RTCP_RTPFB_NACK) {
                        uint32_t *nack = (uint32_t *) extp->body;
                        int i;
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "Got NACK count %d\n", ntohs(extp->header.length) - 2);


                        for (i = 0; i < ntohs(extp->header.length) - 2; i++) {
                                handle_nack(rtp_session, *nack);
                                nack++;
                        }

                        switch_core_media_gen_key_frame(rtp_session->session);
                }

        } else

                if (msg->header.type == _RTCP_PT_SR || msg->header.type == _RTCP_PT_RR) {
                        switch_time_t now;
                        switch_time_exp_t now_hr;
                        uint32_t sec, ntp_sec, ntp_usec, lsr_now;
                        uint32_t lsr;
                        uint32_t packet_ssrc;

                        now = switch_time_now();  /* number of microseconds since 00:00:00 january 1, 1970 UTC */
                        sec = (uint32_t)(now/1000000);              /* converted to second (NTP most significant bits) */
                        ntp_sec = sec+NTP_TIME_OFFSET;  /* 32bits most significant */
                        ntp_usec = (uint32_t)(now - (sec*1000000)); /* micro seconds */
                        lsr_now = (uint32_t)(ntp_usec*0.065536) | (ntp_sec&0x0000ffff)<<16; // 0.065536 is used for convertion from useconds 

                        if (msg->header.type == _RTCP_PT_SR) { /* Sender report */
                                struct switch_rtcp_sender_report* sr = (struct switch_rtcp_sender_report*)msg->body;
                                
                                rtp_session->stats.rtcp.packet_count += ntohl(sr->sender_info.pc);
                                rtp_session->stats.rtcp.octet_count += ntohl(sr->sender_info.oc);
                                packet_ssrc = sr->ssrc;
                                /* Extracting LSR from NTP timestamp and save it */
                                lsr = (ntohl(sr->sender_info.ntp_lsw)&0xffff0000)>>16 | (ntohl(sr->sender_info.ntp_msw)&0x0000ffff)<<16; /* The middle 32 bits out of 64 in the NTP timestamp */
                                rtp_session->stats.rtcp.last_recv_lsr_peer = htonl(lsr);  /* Save it include it in the next SR */
                                rtp_session->stats.rtcp.last_recv_lsr_local = lsr_now;    /* Save it to calculate DLSR when generating next SR */
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG10,"Received a SR with %d report blocks, " \
                                                                  "length in words = %d, " \
                                                                  "SSRC = 0x%X, " \
                                                                  "NTP MSW = %u, " \
                                                                  "NTP LSW = %u, " \
                                                                  "RTP timestamp = %u, " \
                                                                  "Sender Packet Count = %u, " \
                                                                  "Sender Octet Count = %u\n",
                                                                  msg->header.count,
                                                                  ntohs((uint16_t)msg->header.length),
                                                                  ntohl(sr->ssrc),
                                                                  ntohl(sr->sender_info.ntp_msw),
                                                                  ntohl(sr->sender_info.ntp_lsw),
                                                                  ntohl(sr->sender_info.ts),
                                                                  ntohl(sr->sender_info.pc),
                                                                  ntohl(sr->sender_info.oc));


                                rtp_session->rtcp_frame.ssrc = ntohl(sr->ssrc);
                                rtp_session->rtcp_frame.packet_type = (uint16_t)rtp_session->rtcp_recv_msg_p->header.type;
                                rtp_session->rtcp_frame.ntp_msw = ntohl(sr->sender_info.ntp_msw);
                                rtp_session->rtcp_frame.ntp_lsw = ntohl(sr->sender_info.ntp_lsw);
                                rtp_session->rtcp_frame.timestamp = ntohl(sr->sender_info.ts);
                                rtp_session->rtcp_frame.packet_count =  ntohl(sr->sender_info.pc);
                                rtp_session->rtcp_frame.octect_count = ntohl(sr->sender_info.oc);

                                for (i = 0; i < (int)msg->header.count && i < MAX_REPORT_BLOCKS ; i++) {
                                        struct switch_rtcp_report_block *report = (struct switch_rtcp_report_block *) (msg->body + (sizeof(struct switch_rtcp_sr_head) + (i * sizeof(struct switch_rtcp_report_block))));
                                        uint32_t old_avg = rtp_session->rtcp_frame.reports[i].loss_avg;
                                        uint8_t percent_fraction = (uint8_t)report->fraction * 100 / 256 ;
                                        if (!rtp_session->rtcp_frame.reports[i].loss_avg) {
                                                rtp_session->rtcp_frame.reports[i].loss_avg = (uint8_t)percent_fraction;
                                        } else {
                                                rtp_session->rtcp_frame.reports[i].loss_avg = (uint32_t)(((float)rtp_session->rtcp_frame.reports[i].loss_avg * .7) +
                                                                                                                                                                 ((float)(uint8_t)percent_fraction * .3));
                                        }

                                        if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->rtcp_frame.reports[i].loss_avg != old_avg) {
                                                switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT, (void *)&rtp_session->rtcp_frame.reports[i].loss_avg, SCCT_NONE, NULL, NULL, NULL);
                                        }

                                        rtp_session->rtcp_frame.reports[i].ssrc = ntohl(report->ssrc);
                                        rtp_session->rtcp_frame.reports[i].fraction = (uint8_t)report->fraction;
                                        rtp_session->rtcp_frame.reports[i].lost = ntohl(report->lost);
                                        rtp_session->rtcp_frame.reports[i].highest_sequence_number_received = ntohl(report->highest_sequence_number_received);
                                        rtp_session->rtcp_frame.reports[i].jitter = ntohl(report->jitter);
                                        rtp_session->rtcp_frame.reports[i].lsr = ntohl(report->lsr);
                                        rtp_session->rtcp_frame.reports[i].dlsr = ntohl(report->dlsr);
                                        if (rtp_session->rtcp_frame.reports[i].lsr && !rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {
                                                double rtt_now;
                                                switch_time_exp_gmt(&now_hr,now);
                                                /* Calculating RTT = A - DLSR - LSR */
                                                rtt_now = (double)(lsr_now - rtp_session->rtcp_frame.reports[i].dlsr - rtp_session->rtcp_frame.reports[i].lsr)/65536;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3,
                                                                        "Receiving an RTCP packet\n[%04d-%02d-%02d %02d:%02d:%02d.%d] SSRC[0x%x]\n"
                                                                        "RTT[%f] = A[%u] - DLSR[%u] - LSR[%u]\n",
                                                                        1900 + now_hr.tm_year, now_hr.tm_mday, now_hr.tm_mon, now_hr.tm_hour, now_hr.tm_min, now_hr.tm_sec, now_hr.tm_usec,
                                                                        rtp_session->rtcp_frame.reports[i].ssrc, rtt_now,
                                                                        lsr_now, rtp_session->rtcp_frame.reports[i].dlsr, rtp_session->rtcp_frame.reports[i].lsr);
                                                if (!rtp_session->rtcp_frame.reports[i].rtt_avg) {
                                                        rtp_session->rtcp_frame.reports[i].rtt_avg = rtt_now;
                                                } else {
                                                        rtp_session->rtcp_frame.reports[i].rtt_avg = (double)((rtp_session->rtcp_frame.reports[i].rtt_avg * .7) + (rtt_now * .3 ));
                                                }
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3, "RTT average %f\n",
                                                                                                                                                                                        rtp_session->rtcp_frame.reports[i].rtt_avg);
                                        }
                                }
                                rtp_session->rtcp_frame.report_count = (uint16_t)i;

                        } else { /* Receiver report */
                                struct switch_rtcp_receiver_report* rr = (struct switch_rtcp_receiver_report*)msg->body;
                                packet_ssrc = rr->ssrc;
                                memset(&rtp_session->rtcp_frame, 0, sizeof(rtp_session->rtcp_frame));
                        }

                        rtp_session->rtcp_fresh_frame = 1;
                        rtp_session->stats.rtcp.peer_ssrc = ntohl(packet_ssrc);
                }
        

        if (msg->header.type > 194 && msg->header.type < 255) {
                status = SWITCH_STATUS_SUCCESS;
        }

        return status;
}

static switch_status_t read_rtcp_packet ( switch_rtp_t *  rtp_session, switch_size_t *  bytes, switch_frame_flag_t *  flags  )

static

Definition at line 6039 of file switch_rtp.c.

References switch_dtls_s::bytes, switch_dtls_s::data, do_dtls(), switch_rtp::flags, handle_ice(), rtcp_msg_t::header, switch_rtp_ice_t::ice_user, if(), process_rtcp_packet(), switch_rtp::recv_ctx, switch_rtp::rtcp_dtls, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_ice, switch_rtp::rtcp_recv_msg_p, switch_rtp::rtcp_sock_input, switch_rtp::session, switch_rtp::srtp_idx_rtcp, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_SECURE_RECV, switch_socket_recvfrom(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_rtcp_hdr_s::version.

Referenced by rtp_common_read().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(bytes);

        *bytes = sizeof(rtcp_msg_t);

        if ((status = switch_socket_recvfrom(rtp_session->rtcp_from_addr, rtp_session->rtcp_sock_input, 0, (void *) rtp_session->rtcp_recv_msg_p, bytes)) 
                != SWITCH_STATUS_SUCCESS) {
                *bytes = 0;
        }

        if (rtp_session->rtcp_dtls) {
                char *b = (char *) rtp_session->rtcp_recv_msg_p;
                
                if (*b == 0 || *b == 1) {
                        if (rtp_session->rtcp_ice.ice_user) {
                                handle_ice(rtp_session, &rtp_session->rtcp_ice, (void *) rtp_session->rtcp_recv_msg_p, *bytes);
                        }
                        *bytes = 0;
                }
                
                if (*bytes && (*b >= 20) && (*b <= 64)) {
                        rtp_session->rtcp_dtls->bytes = *bytes;
                        rtp_session->rtcp_dtls->data = (void *) rtp_session->rtcp_recv_msg_p;
                } else {
                        rtp_session->rtcp_dtls->bytes = 0;
                        rtp_session->rtcp_dtls->data = NULL;
                }
                
                do_dtls(rtp_session, rtp_session->rtcp_dtls);
                

                if (rtp_session->rtcp_dtls->bytes) {
                        *bytes = 0;
                }
        }



#ifdef ENABLE_SRTP
        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && rtp_session->rtcp_recv_msg_p->header.version == 2) {
                //if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && (!rtp_session->ice.ice_user || rtp_session->rtcp_recv_msg_p->header.version == 2)) {
                int sbytes = (int) *bytes;
                err_status_t stat = 0;
                

                if ((stat = srtp_unprotect_rtcp(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes))) {
                        //++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp]++;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "RTCP UNPROTECT ERR\n");
                } else {
                        //rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
                }
                
                *bytes = sbytes;
                
        }
#endif


#ifdef ENABLE_ZRTP
        if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && rtp_session->rtcp_recv_msg_p->header.version == 2) {
                /* ZRTP Recv */
                if (bytes) {
                        unsigned int sbytes = (int) *bytes;
                        zrtp_status_t stat = 0;
                        
                        stat = zrtp_process_srtcp(rtp_session->zrtp_stream, (void *) rtp_session->rtcp_recv_msg_p, &sbytes);
                        
                        switch (stat) {
                        case zrtp_status_ok:
                                *bytes = sbytes;
                                break;
                        case zrtp_status_drop:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
                                *bytes = 0;
                                break;
                        case zrtp_status_fail:
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                *bytes = 0;
                                break;
                        default:
                                break;
                        }
                }
        }
#endif


        if (*bytes) {
                return process_rtcp_packet(rtp_session, bytes);
        }

        return status;
}

static switch_status_t read_rtp_packet ( switch_rtp_t *  rtp_session, switch_size_t *  bytes, switch_frame_flag_t *  flags, switch_status_t  poll_status, switch_bool_t  return_jb_packet  )

static

Definition at line 5133 of file switch_rtp.c.

References switch_dtls_s::bytes, check_jitter(), check_recv_payload(), check_rtcp_and_ice(), switch_rtp::clean, switch_rtp_numbers_t::cng_packet_count, switch_rtp::cng_pt, switch_dtls_s::data, do_dtls(), switch_rtp::dtls, switch_rtp_numbers_t::dtmf_packet_count, rtp_msg_t::ebody, rtp_msg_t::ext, switch_rtp::flags, switch_rtp_numbers_t::flush_packet_count, switch_rtp::from_addr, get_recv_payload(), handle_ice(), switch_rtp::has_ice, switch_rtp::has_rtcp, switch_rtp::has_rtp, rtp_msg_t::header, rtcp_msg_t::header, switch_rtp::hot_hits, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_rtp_stats_t::inbound, switch_timer::interval, switch_rtp::jb, switch_rtp_numbers_t::jb_packet_count, jb_valid(), switch_rtp::last_cng_ts, switch_rtp::last_flush_packet_count, switch_rtp::last_jb_read_ssrc, switch_rtp::last_read_time, switch_rtp::last_read_ts, switch_rtp::last_rtp_hdr, switch_rtp::last_seq, switch_rtp_hdr_ext_t::length, switch_rtp::local_addr, MAX_SRTP_ERRS, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, memset(), switch_rtp::missed_count, switch_rtp_numbers_t::packet_count, switch_rtp::pause_jb, switch_rtp::punts, switch_rtp_numbers_t::raw_bytes, switch_rtp::read_pollfd, switch_rtp::recv_ctx, switch_rtp::recv_msg, switch_rtp::recv_policy, switch_rtp::recv_te, switch_rtp::remote_addr, switch_rtp::remote_port, reset_jitter_seq(), switch_rtp::rtcp_dtls, switch_rtp::rtcp_recv_msg_p, rtcp_stats(), RTP_BODY, RTP_BUG_IGNORE_MARK_BIT, switch_rtp::rtp_bugs, switch_rtp::rtp_from_addr, rtp_header_len, rtp_type, rtp_write_ready(), switch_rtp::session, SFF_PLC, SFF_PROXY_PACKET, SFF_RTCP, switch_rtp::sock_input, switch_rtp::srtp_errs, switch_rtp::srtp_idx_rtcp, switch_rtp::srtp_idx_rtp, switch_rtp::stats, switch_assert, SWITCH_CAUSE_SRTP_READ_ERROR, switch_channel_get_name(), switch_channel_hangup, SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CHANNEL_SESSION_LOG_CLEAN, switch_core_session_get_channel(), switch_core_session_request_video_refresh(), switch_core_timer_sync(), switch_cp_addr(), switch_get_addr(), switch_jb_destroy(), switch_jb_get_last_read_len(), switch_jb_get_packet(), switch_jb_put_packet(), switch_jb_reset(), SWITCH_LOG_ALERT, SWITCH_LOG_CONSOLE, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, switch_micro_time_now(), switch_poll(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_BYTESWAP, SWITCH_RTP_FLAG_DEBUG_RTP_READ, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_FLUSH, SWITCH_RTP_FLAG_KILL_JB, SWITCH_RTP_FLAG_NACK, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_RECV_RESET, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_MAX_BUF_LEN_WORDS, switch_rtp_set_flag(), switch_rtp_video_refresh(), switch_sockaddr_get_port(), switch_socket_recvfrom(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_MORE_DATA, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_RESTART, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TOO_LATE, switch_swap_linear(), switch_rtp::timer, switch_rtcp_sender_info::ts, switch_rtcp_hdr_s::type, switch_rtp::vb, switch_rtcp_hdr_s::version, WARN_SRTP_ERRS, and ZRTP_MAGIC_COOKIE.

Referenced by rtp_common_read().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint32_t ts = 0;
        unsigned char *b = NULL;
        int sync = 0;
        switch_time_t now;
        switch_size_t xcheck_jitter = 0;
        int tries = 0;
        int block = 0;
        
        switch_assert(bytes);
 more:

        tries++;

        if (tries > 20) {
                if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
                        switch_jb_reset(rtp_session->jb);
                }
                rtp_session->punts++;
                rtp_session->clean = 0;
                *bytes = 0;
                return SWITCH_STATUS_BREAK;
        }
                
        if (block) {
                int to = 20000;
                int fdr = 0;

                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        to = 100000;
                } else {
                        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
                                to = rtp_session->timer.interval * 1000;
                        }
                }
                
                poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, to);
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
                        switch_core_timer_sync(&rtp_session->timer);
                }
                
                block = 0;
        }
        
        *bytes = sizeof(rtp_msg_t);
        sync = 0;

        rtp_session->has_rtp = 0;
        rtp_session->has_ice = 0;
        rtp_session->has_rtcp = 0;
        if (rtp_session->dtls) {
                rtp_session->dtls->bytes = 0;
                rtp_session->dtls->data = NULL;
        }
        memset(&rtp_session->last_rtp_hdr, 0, sizeof(rtp_session->last_rtp_hdr));

        if (poll_status == SWITCH_STATUS_SUCCESS) {
                status = switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, bytes);
        } else {
                *bytes = 0;
        }

        if (*bytes) {
                b = (unsigned char *) &rtp_session->recv_msg;
                
                /* version 2 probably rtp, zrtp cookie present means zrtp */
                rtp_session->has_rtp = (rtp_session->recv_msg.header.version == 2 || ntohl(*(int *)(b+4)) == ZRTP_MAGIC_COOKIE);

                if ((*b >= 20) && (*b <= 64)) {
                        if (rtp_session->dtls) {
                                rtp_session->dtls->bytes = *bytes;
                                rtp_session->dtls->data = (void *) &rtp_session->recv_msg;
                        }
                        rtp_session->has_ice = 0;
                        rtp_session->has_rtp = 0;
                        rtp_session->has_rtcp = 0;
                } else if (*b == 0 || *b == 1) {
                        rtp_session->has_ice = 1;
                        rtp_session->has_rtp = 0;
                        rtp_session->has_rtcp = 0;
                } else {
                        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                                switch(rtp_session->recv_msg.header.pt) {
                                case 64:        //  192 Full INTRA-frame request.
                                case 72:        //  200 Sender report.
                                case 73:        //  201 Receiver report.
                                case 74:        //  202 Source description.
                                case 75:        //  203 Goodbye.
                                case 76:        //  204 Application-defined.
                                case 77:        //  205 Transport layer FB message.
                                case 78:        //  206 Payload-specific FB message.
                                case 79:        //  207 Extended report.
                                        rtp_session->has_rtcp = 1;
                                        rtp_session->has_rtp = 0;
                                        rtp_session->has_ice = 0;
                                        break;
                                default:
                                        if (rtp_session->rtcp_recv_msg_p->header.version == 2 && 
                                                rtp_session->rtcp_recv_msg_p->header.type > 199 && rtp_session->rtcp_recv_msg_p->header.type < 208) {
                                                rtp_session->has_rtcp = 1;
                                                rtp_session->has_rtp = 0;
                                                rtp_session->has_ice = 0;
                                        }
                                        break;
                                }                                               
                        }
                }

                if (rtp_session->has_rtp) {
                        rtp_session->missed_count = 0;
                        switch_cp_addr(rtp_session->rtp_from_addr, rtp_session->from_addr);     
                        rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
                }
        }

        if (!rtp_session->vb && (!rtp_session->jb || rtp_session->pause_jb || !jb_valid(rtp_session))) {
                if (*bytes > rtp_header_len && (rtp_session->has_rtp && check_recv_payload(rtp_session))) {
                        xcheck_jitter = *bytes;
                        check_jitter(rtp_session);
                }
        }

        if (check_rtcp_and_ice(rtp_session) == -1) {
                //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF CHECK FAIL\n");
                //}
                return SWITCH_STATUS_GENERR;
        }
        
        if (rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                goto udptl;
        }


        if (*bytes) {
                *flags &= ~SFF_PROXY_PACKET;

                //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF BYTES %ld b=%d\n", *bytes, *b);
                //}

                
                if (rtp_session->has_ice) {
                        if (rtp_session->ice.ice_user) {
                                handle_ice(rtp_session, &rtp_session->ice, (void *) &rtp_session->recv_msg, *bytes);
                        }
                        *bytes = 0;
                        sync = 1;
                }
        }

        if (rtp_session->dtls) {
                
                if (rtp_session->rtcp_dtls && rtp_session->rtcp_dtls != rtp_session->dtls) {
                        rtp_session->rtcp_dtls->bytes = 0;
                        rtp_session->rtcp_dtls->data = NULL;
                        do_dtls(rtp_session, rtp_session->rtcp_dtls);
                }

                do_dtls(rtp_session, rtp_session->dtls);

                if (rtp_session->dtls && rtp_session->dtls->bytes) {
                        *bytes = 0;
                        sync = 1;
                }
        }

        if (status == SWITCH_STATUS_SUCCESS && *bytes) { 
                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) { 
                        *flags &= ~SFF_RTCP;
                        if (rtp_session->has_rtcp) {
                                *flags |= SFF_RTCP;

#ifdef ENABLE_SRTP
                                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
                                        int sbytes = (int) *bytes;
                                        err_status_t stat = 0;
                                        
                                        
                                        if ((stat = srtp_unprotect_rtcp(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes))) {
                                                //++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp]++;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "RTCP UNPROTECT ERR\n");
                                        } else {
                                                //rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
                                        }
                                        
                                        *bytes = sbytes;
                                }
#endif
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        

        if ((*bytes && (!rtp_write_ready(rtp_session, *bytes, __LINE__) || !rtp_session->has_rtp || rtp_session->has_rtcp)) || sync) {
                rtp_session->hot_hits = 0;
                block = 1;
                *bytes = 0;
                goto more;
        }

        if (*bytes && rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]) {
                const char *tx_host;
                const char *old_host;
                const char *my_host;

                char bufa[50], bufb[50], bufc[50];


                tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
                old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
                my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_CONSOLE,
                                                  "R %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
                                                  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "No-Name",
                                                  (long) *bytes,
                                                  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
                                                  old_host, rtp_session->remote_port,
                                                  tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
                                                  rtp_session->last_rtp_hdr.pt, ntohl(rtp_session->last_rtp_hdr.ts), ntohs(rtp_session->last_rtp_hdr.seq), 
                                                  rtp_session->last_rtp_hdr.m);

        }

#ifdef RTP_READ_PLOSS
        {
                int r = (rand() % 10000) + 1;
                if (r <= 200) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ALERT, 
                                                          "Simulate dropped packet ......... ts: %u seq: %u\n", ntohl(rtp_session->last_rtp_hdr.ts), ntohs(rtp_session->last_rtp_hdr.seq));
                        *bytes = 0;
                }
        }
#endif



 udptl:

        ts = 0;
        rtp_session->recv_msg.ebody = NULL;
        now = switch_micro_time_now();

        if (*bytes) {
                uint16_t seq = ntohs((uint16_t) rtp_session->last_rtp_hdr.seq);
                ts = ntohl(rtp_session->last_rtp_hdr.ts);

#ifdef DEBUG_MISSED_SEQ         
                if (rtp_session->last_seq && rtp_session->last_seq+1 != seq) {
                        //2012-11-28 18:33:11.799070 [ERR] switch_rtp.c:2883 Missed -65536 RTP frames from sequence [65536] to [-1] (missed). Time since last read [20021]
                        switch_size_t flushed_packets_diff = rtp_session->stats.inbound.flush_packet_count - rtp_session->last_flush_packet_count;
                        switch_size_t num_missed = (switch_size_t)seq - (rtp_session->last_seq+1);

                        if (num_missed == 1) { /* We missed one packet */
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missed one RTP frame with sequence [%d]%s. Time since last read [%ld]\n",
                                                                  rtp_session->last_seq+1, (flushed_packets_diff == 1) ? " (flushed by FS)" : " (missed)",
                                                                  rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
                        } else { /* We missed multiple packets */
                                if (flushed_packets_diff == 0) { 
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                          "Missed %ld RTP frames from sequence [%d] to [%d] (missed). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
                                } else if (flushed_packets_diff == num_missed) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                          "Missed %ld RTP frames from sequence [%d] to [%d] (flushed by FS). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
                                } else if (num_missed > flushed_packets_diff) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                          "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS, %ld packets missed)."
                                                                          " Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          flushed_packets_diff, num_missed-flushed_packets_diff,
                                                                          rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
                                                                          "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS). Time since last read [%ld]\n",
                                                                          num_missed, rtp_session->last_seq+1, seq-1,
                                                                          flushed_packets_diff, rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
                                }
                        }

                }
#endif
                rtp_session->last_seq = seq;
        

                rtp_session->last_flush_packet_count = rtp_session->stats.inbound.flush_packet_count;
                
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && now - rtp_session->last_read_time > 5000000) {
                        switch_rtp_video_refresh(rtp_session);
                }

                rtp_session->last_read_time = now;
        }

        if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && 
                *bytes && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te && 
                ts && !rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session) && ts == rtp_session->last_cng_ts) {
                /* we already sent this frame..... */
                *bytes = 0;
                return SWITCH_STATUS_SUCCESS;
        }

        if (*bytes) {
                if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
#ifdef ENABLE_ZRTP
                        /* ZRTP Recv */
                        if (zrtp_on) {
                                
                                unsigned int sbytes = (int) *bytes;
                                zrtp_status_t stat = 0;
                                
                                stat = zrtp_process_srtp(rtp_session->zrtp_stream, (void *) &rtp_session->recv_msg, &sbytes);
                                
                                switch (stat) {
                                case zrtp_status_ok:
                                        *bytes = sbytes;
                                        break;
                                case zrtp_status_drop:
                                        /* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error: zRTP protection drop with code %d\n", stat); */
                                        *bytes = 0;
                                        return SWITCH_STATUS_SUCCESS;
                                case zrtp_status_fail:
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                        return SWITCH_STATUS_FALSE;
                                default:
                                        break;
                                }
                        }
#endif
                        
#ifdef ENABLE_SRTP
                        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && rtp_session->has_rtp && 
                                (check_recv_payload(rtp_session) || 
                                 rtp_session->last_rtp_hdr.pt == rtp_session->recv_te || 
                                 rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt)) {
                                //if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && (!rtp_session->ice.ice_user || rtp_session->has_rtp)) {
                                int sbytes = (int) *bytes;
                                err_status_t stat = 0;

                                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_RESET] || !rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]) {
                                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV_RESET);
                                        srtp_dealloc(rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]);
                                        rtp_session->recv_ctx[rtp_session->srtp_idx_rtp] = NULL;
                                        if ((stat = srtp_create(&rtp_session->recv_ctx[rtp_session->srtp_idx_rtp], 
                                                                                        &rtp_session->recv_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]) {
                                                
                                                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP RECV\n");
                                                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
                                                return SWITCH_STATUS_FALSE;
                                        } else {
                                                
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "RE-Activating Secure RTP RECV\n");
                                                rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
                                        }
                                }

                                if (!(*flags & SFF_PLC)) {
                                        stat = srtp_unprotect(rtp_session->recv_ctx[rtp_session->srtp_idx_rtp], &rtp_session->recv_msg.header, &sbytes);
                                        if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && stat == err_status_replay_fail) {
                                                /* false alarm nack */
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "REPLAY ERR, FALSE NACK\n");
                                                stat = 0;
                                                sbytes = 0;
                                                *bytes = 0;
                                                goto more;
                                        }
                                }

                                if (stat && rtp_session->recv_msg.header.pt != rtp_session->recv_te && rtp_session->recv_msg.header.pt != rtp_session->cng_pt) {
                                        int errs = ++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp];
                                        if (stat != 10) {
                                                char *msg;
                                                if (stat == err_status_replay_fail) msg="replay check failed";
                                                else if (stat == err_status_auth_fail) msg="auth check failed";
                                                else msg="";
                                                if (errs >= MAX_SRTP_ERRS) {
                                                        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR,
                                                                                          "SRTP %s unprotect failed with code %d (%s) %ld bytes %d errors\n",
                                                                                          rtp_type(rtp_session), stat, msg, (long)*bytes, errs);
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR,
                                                                                          "Ending call due to SRTP error\n");
                                                        switch_channel_hangup(channel, SWITCH_CAUSE_SRTP_READ_ERROR);
                                                } else if (errs >= WARN_SRTP_ERRS && !(errs % WARN_SRTP_ERRS)) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING,
                                                                                          "SRTP %s unprotect failed with code %d (%s) %ld bytes %d errors\n",
                                                                                          rtp_type(rtp_session), stat, msg, (long)*bytes, errs);
                                                }
                                        }
                                        sbytes = 0;
                                } else {
                                        rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
                                }

                                *bytes = sbytes;
                        }
#endif
                }


                if (rtp_session->has_rtp) {
                        if (rtp_session->recv_msg.header.cc > 0) { /* Contributing Source Identifiers (4 bytes = sizeof CSRC header)*/
                                rtp_session->recv_msg.ebody = RTP_BODY(rtp_session) + (rtp_session->recv_msg.header.cc * 4);
                        }

                        /* recalculate body length in case rtp extension used */
                        if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
                                rtp_session->has_rtp && rtp_session->recv_msg.header.x) { /* header extensions */
                                uint16_t length;
                        
                                rtp_session->recv_msg.ext = (switch_rtp_hdr_ext_t *) RTP_BODY(rtp_session);
                                length = ntohs((uint16_t)rtp_session->recv_msg.ext->length);
                
                                if (length < SWITCH_RTP_MAX_BUF_LEN_WORDS) {
                                        rtp_session->recv_msg.ebody = (char *)rtp_session->recv_msg.ext + (length * 4) + 4;
                                        if (*bytes > (length * 4 + 4)) {
                                                *bytes -= (length * 4 + 4);
                                        } else {
                                                *bytes = 0;
                                        }
                                }
                        }


#ifdef DEBUG_CHROME
                        
                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->has_rtp) {
                
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, 
                                                                  "VIDEO: seq: %d ts: %u len: %ld %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x mark: %d\n",
                                                                  ntohs(rtp_session->last_rtp_hdr.seq), ntohl(rtp_session->last_rtp_hdr.ts), *bytes,
                                                                  *((uint8_t *)RTP_BODY(rtp_session)), *((uint8_t *)RTP_BODY(rtp_session) + 1),
                                                                  *((uint8_t *)RTP_BODY(rtp_session) + 2), *((uint8_t *)RTP_BODY(rtp_session) + 3),
                                                                  *((uint8_t *)RTP_BODY(rtp_session) + 4), *((uint8_t *)RTP_BODY(rtp_session) + 5),
                                                                  *((uint8_t *)RTP_BODY(rtp_session) + 6), *((uint8_t *)RTP_BODY(rtp_session) + 7),
                                                                  *((uint8_t *)RTP_BODY(rtp_session) + 8), *((uint8_t *)RTP_BODY(rtp_session) + 9),
                                                                  *((uint8_t *)RTP_BODY(rtp_session) + 10), rtp_session->last_rtp_hdr.m);
                        
                        }
#endif          



                        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                                rtcp_stats(rtp_session);
                        }
                }

                
                rtp_session->stats.inbound.raw_bytes += *bytes;
                
                if (rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
                        rtp_session->stats.inbound.dtmf_packet_count++;
                } else if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
                        rtp_session->stats.inbound.cng_packet_count++;
                } else {
                        rtp_session->stats.inbound.media_packet_count++;
                        rtp_session->stats.inbound.media_bytes += *bytes;
                }

                rtp_session->stats.inbound.packet_count++;
        }

        if (rtp_session->last_rtp_hdr.pt == rtp_session->recv_te || 
                (*bytes < rtp_header_len && *bytes > 0) ||
                rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                return SWITCH_STATUS_BREAK;
        }

        if (ts) {
                rtp_session->last_read_ts = ts;
        }
        
        if (rtp_session->flags[SWITCH_RTP_FLAG_BYTESWAP] && check_recv_payload(rtp_session)) {
                switch_swap_linear((int16_t *)RTP_BODY(rtp_session), (int) *bytes - rtp_header_len);
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB]) {
                rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB] = 0;

                if (rtp_session->jb) {
                        switch_jb_destroy(&rtp_session->jb);
                }

                if (rtp_session->vb) {
                        switch_jb_destroy(&rtp_session->vb);
                }
        }

        if (rtp_session->has_rtp && *bytes) {
                uint32_t read_ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc);

                if (rtp_session->vb && jb_valid(rtp_session)) {
                        status = switch_jb_put_packet(rtp_session->vb, (switch_rtp_packet_t *) &rtp_session->recv_msg, *bytes);                 

                        if (status == SWITCH_STATUS_TOO_LATE) {
                                goto more;
                        }
                        
                        status = SWITCH_STATUS_FALSE;
                        *bytes = 0;

                        if (!return_jb_packet) {
                                return status;
                        }
                }

                if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {

                        if (rtp_session->last_jb_read_ssrc && rtp_session->last_jb_read_ssrc != read_ssrc) {
                                switch_jb_reset(rtp_session->jb);
                        }

                        rtp_session->last_jb_read_ssrc = read_ssrc;

                        if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
                                switch_core_timer_sync(&rtp_session->timer);
                                reset_jitter_seq(rtp_session);
                        }

                        status = switch_jb_put_packet(rtp_session->jb, (switch_rtp_packet_t *) &rtp_session->recv_msg, *bytes);
                        if (status == SWITCH_STATUS_TOO_LATE) {
                                goto more;
                        }

                        
                        status = SWITCH_STATUS_FALSE;
                        *bytes = 0;

                        if (!return_jb_packet) {
                                return status;
                        }
                } else {
                        if (rtp_session->last_rtp_hdr.m && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te && 
                                !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && !(rtp_session->rtp_bugs & RTP_BUG_IGNORE_MARK_BIT)) {
                                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
                        } else if (rtp_session->last_jb_read_ssrc && rtp_session->last_jb_read_ssrc != read_ssrc) {
                                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
                        }
                }
        }

        if (!*bytes || rtp_session->has_rtp) {
                
                if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
                        switch_status_t jstatus = switch_jb_get_packet(rtp_session->jb, (switch_rtp_packet_t *) &rtp_session->recv_msg, bytes);

                        status = jstatus;

                        switch(jstatus) {
                        case SWITCH_STATUS_MORE_DATA:
                                if (rtp_session->punts < 4) {
                                        block = 1;
                                        goto more;
                                }
                                *bytes = 0;
                                break;
                        case SWITCH_STATUS_NOTFOUND:
                                {
                                        int pt = get_recv_payload(rtp_session);
                                        (*flags) |= SFF_PLC;
                                        status = SWITCH_STATUS_SUCCESS;
                                        *bytes = switch_jb_get_last_read_len(rtp_session->jb);
                                        rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
                                        if (pt > -1) {
                                                rtp_session->last_rtp_hdr.pt = pt;
                                        }
                                }
                                break;
                        case SWITCH_STATUS_SUCCESS:
                        default:
                                {
                                        rtp_session->stats.inbound.jb_packet_count++;
                                        status = SWITCH_STATUS_SUCCESS;
                                        rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
                                        if (++rtp_session->clean > 200) {
                                                rtp_session->punts = 0;
                                        }
                                        if (!xcheck_jitter) {
                                                check_jitter(rtp_session);
                                                xcheck_jitter = *bytes;
                                        }
                                }
                                break;
                        }
                }
                
                if (rtp_session->vb && jb_valid(rtp_session)) {
                        switch_status_t vstatus = switch_jb_get_packet(rtp_session->vb, (switch_rtp_packet_t *) &rtp_session->recv_msg, bytes);
                        status = vstatus;

                        switch(vstatus) {
                        case SWITCH_STATUS_RESTART:
                                switch_core_session_request_video_refresh(rtp_session->session);
                                status = SWITCH_STATUS_BREAK;
                                break;
                        case SWITCH_STATUS_MORE_DATA:
                                status = SWITCH_STATUS_BREAK;
                                break;
                        case SWITCH_STATUS_BREAK:
                                switch_core_session_request_video_refresh(rtp_session->session);
                        default:
                                break;
                        }
                
                        if (vstatus == SWITCH_STATUS_SUCCESS) {
                                rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
                                if (!xcheck_jitter) {
                                        check_jitter(rtp_session);
                                        xcheck_jitter = *bytes;
                                }
                        }
                }
        }

        return status;
}

static void reset_jitter_seq ( switch_rtp_t *  rtp_session )

static

Definition at line 1595 of file switch_rtp.c.

References switch_rtp::consecutive_flaws, switch_rtp_stats_t::inbound, switch_rtp::jitter_lead, switch_rtp_numbers_t::last_flaw, switch_rtp_numbers_t::last_proc_time, switch_rtp_numbers_t::last_processed_seq, and switch_rtp::stats.

Referenced by check_jitter(), do_flush(), read_rtp_packet(), rtp_common_read(), rtp_flush_read_buffer(), switch_rtp_clear_flag(), and switch_rtp_set_flag().

{
        rtp_session->stats.inbound.last_proc_time = 0;
        rtp_session->stats.inbound.last_processed_seq = 0;
        rtp_session->jitter_lead = 0;
        rtp_session->consecutive_flaws = 0;
        rtp_session->stats.inbound.last_flaw = 0;
}

static void rtcp_generate_report_block ( switch_rtp_t *  rtp_session, struct switch_rtcp_report_block *  rtcp_report_block  )

static

Definition at line 1756 of file switch_rtp.c.

References switch_rtcp_numbers_t::base_seq, switch_rtcp_numbers_t::cum_lost, switch_rtcp_numbers_t::cycle, switch_rtcp_report_block::dlsr, switch_rtp::flags, switch_rtcp_report_block::fraction, switch_rtcp_numbers_t::high_ext_seq_recv, switch_rtcp_report_block::highest_sequence_number_received, switch_rtcp_numbers_t::inter_jitter, switch_rtcp_report_block::jitter, switch_rtcp_numbers_t::last_recv_lsr_local, switch_rtcp_numbers_t::last_recv_lsr_peer, switch_rtcp_numbers_t::last_rpt_cycle, switch_rtcp_numbers_t::last_rpt_ext_seq, switch_rtcp_report_block::lost, switch_rtcp_report_block::lsr, NTP_TIME_OFFSET, switch_rtcp_numbers_t::peer_ssrc, switch_rtcp_numbers_t::period_pkt_count, switch_rtp::pool, switch_rtp::remote_ssrc, switch_rtp_stats_t::rtcp, switch_rtcp_numbers_t::rtcp_rtp_count, switch_rtcp_report_block::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_core_memory_pool_get_data(), SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_RTP_FLAG_VIDEO, and switch_time_now().

Referenced by check_rtcp_and_ice().

                                                                                                                     {
#ifdef DEBUG_RTCP
        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
#endif
        switch_rtcp_numbers_t * stats=&rtp_session->stats.rtcp;
        switch_time_t now;
        uint32_t expected_pkt, dlsr;
        int32_t pkt_lost;
        uint32_t ntp_sec, ntp_usec, lsr_now, sec;
        now = switch_time_now();
        sec = (uint32_t)(now/1000000);        /* convert to seconds     */
        ntp_sec = sec+NTP_TIME_OFFSET;  /* convert to NTP seconds */
        ntp_usec = (uint32_t)(now - (sec*1000000)); /* remove seconds to keep only the microseconds */

        /* Packet loss */
        if (stats->rtcp_rtp_count == 0) {
                expected_pkt = stats->high_ext_seq_recv - stats->base_seq + 1;
        } else {
                expected_pkt = stats->high_ext_seq_recv - stats->last_rpt_ext_seq;
        }
        
        pkt_lost = expected_pkt - stats->period_pkt_count;
        stats->cum_lost=stats->cum_lost+pkt_lost;
        if (expected_pkt > 0 && pkt_lost > 0) {
                rtcp_report_block->fraction = (uint8_t) (pkt_lost * 256 / expected_pkt);
        } else {
                rtcp_report_block->fraction = 0;
        }
#if SWITCH_BYTE_ORDER != __BIG_ENDIAN
        /* Reversing byte order for 24bits */
        rtcp_report_block->lost = (((stats->cum_lost&0x0000FF)<<16) | ((stats->cum_lost&0x00FF00)) | ((stats->cum_lost&0xFF0000)>>16));
#endif

#ifdef DEBUG_RTCP
                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO])
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "rtcp_generate_sr: stats_ssrc[%u]\nreceived[%d]\nexpected[%d]\ncum[%d]\nlost[%d|%d/256]pkt\nlast_seq[%d]\ncyc[%d]\nlast_rpt_seq[%d]\ncyc[%d]\nssrc[%d]\n",
                                                rtp_session->remote_ssrc, stats->period_pkt_count, expected_pkt,
                                                stats->cum_lost, pkt_lost, rtcp_report_block->fraction, stats->high_ext_seq_recv&0x0000ffff,
                                                stats->cycle, stats->last_rpt_ext_seq&0x0000ffff, stats->last_rpt_cycle, rtp_session->stats.rtcp.peer_ssrc
                                                );
#endif
        rtcp_report_block->highest_sequence_number_received = htonl(stats->high_ext_seq_recv);

        /* Jitter */
        rtcp_report_block->jitter = htonl((uint32_t)stats->inter_jitter);

        /* Delay since Last Sender Report (DLSR) : 32bits, 1/65536 seconds */
        lsr_now = (uint32_t)(ntp_usec*0.065536) | (ntp_sec&0x0000ffff)<<16; /* 0.065536 is used for convertion from useconds to fraction of 65536 (x65536/1000000) */

        if (stats->last_recv_lsr_local) {
                dlsr = lsr_now - stats->last_recv_lsr_local;
        } else {
                dlsr = 0;
        }
        rtcp_report_block->lsr = stats->last_recv_lsr_peer;
        rtcp_report_block->dlsr = htonl(dlsr);
        rtcp_report_block->ssrc = htonl(rtp_session->stats.rtcp.peer_ssrc);
        stats->rtcp_rtp_count++;
}

static void rtcp_generate_sender_info ( switch_rtp_t *  rtp_session, struct switch_rtcp_sender_info *  sr  )

static

Definition at line 1731 of file switch_rtp.c.

References switch_rtp::last_write_ts, switch_rtcp_sender_info::ntp_lsw, switch_rtcp_sender_info::ntp_msw, NTP_TIME_OFFSET, switch_rtcp_sender_info::oc, switch_rtp_stats_t::outbound, switch_rtp_numbers_t::packet_count, switch_rtcp_sender_info::pc, switch_rtp::pool, switch_rtp_numbers_t::raw_bytes, switch_rtp_stats_t::rtcp, switch_rtcp_numbers_t::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_core_memory_pool_get_data(), SWITCH_LOG_DEBUG10, switch_log_printf(), switch_time_exp_gmt(), switch_time_now(), switch_time_exp_t::tm_hour, switch_time_exp_t::tm_mday, switch_time_exp_t::tm_min, switch_time_exp_t::tm_mon, switch_time_exp_t::tm_sec, switch_time_exp_t::tm_usec, switch_time_exp_t::tm_year, and switch_rtcp_sender_info::ts.

Referenced by check_rtcp_and_ice().

                                                                                                    {
        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
        switch_time_t now;
        uint32_t sec, ntp_sec, ntp_usec;
        switch_time_exp_t now_hr;
        now = switch_time_now();
        sec = (uint32_t)(now/1000000);        /* convert to seconds     */
        ntp_sec = sec+NTP_TIME_OFFSET;  /* convert to NTP seconds */
        sr->ntp_msw = htonl(ntp_sec);   /* store result in "most significant word" */
        ntp_usec = (uint32_t)(now - (sec*1000000)); /* remove seconds to keep only the microseconds */
        sr->ntp_lsw = htonl((u_long)(ntp_usec*(double)(((uint64_t)1)<<32)*1.0e-6)); /* convert microseconds to fraction of 32bits and store result in "least significatn word" */

        sr->ts = htonl(rtp_session->last_write_ts);
        sr->pc = htonl(rtp_session->stats.outbound.packet_count);
        sr->oc = htonl((rtp_session->stats.outbound.raw_bytes - rtp_session->stats.outbound.packet_count * sizeof(srtp_hdr_t)));

        switch_time_exp_gmt(&now_hr,now);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10,"Sending an RTCP packet[%04d-%02d-%02d %02d:%02d:%02d.%d] lsr[%u] msw[%u] lsw[%u] stats_ssrc[%u]\n",
                        1900 + now_hr.tm_year,  now_hr.tm_mday, now_hr.tm_mon, now_hr.tm_hour, now_hr.tm_min, now_hr.tm_sec, now_hr.tm_usec,
                        (ntohl(sr->ntp_lsw)&0xffff0000)>>16 | (ntohl(sr->ntp_msw)&0x0000ffff)<<16,
                        ntohl(sr->ntp_msw),ntohl(sr->ntp_lsw), rtp_session->stats.rtcp.ssrc
                        );
}

static int rtcp_stats ( switch_rtp_t *  rtp_session )

static

Definition at line 1849 of file switch_rtp.c.

References switch_rtcp_numbers_t::bad_seq, switch_rtcp_numbers_t::cycle, switch_rtp::flags, switch_rtcp_numbers_t::high_ext_seq_recv, switch_rtcp_numbers_t::init, switch_rtcp_numbers_t::inter_jitter, switch_rtcp_numbers_t::last_pkt_tsdiff, switch_rtp::last_rtp_hdr, switch_rtcp_numbers_t::period_pkt_count, switch_rtcp_numbers_t::pkt_count, switch_rtp::pool, switch_rtp_stats_t::rtcp, switch_rtp::rtcp_interval, switch_rtp::rtcp_sock_output, rtcp_stats_init(), switch_timer::samplecount, switch_rtcp_numbers_t::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_core_memory_pool_get_data(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG10, switch_log_printf(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_RTCP_PASSTHRU, and switch_rtp::timer.

Referenced by read_rtp_packet().

{
        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
        srtp_hdr_t * hdr = &rtp_session->last_rtp_hdr;
        switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
        uint32_t packet_spacing_diff = 0, pkt_tsdiff, pkt_extended_seq;
        uint16_t pkt_seq, seq_diff, max_seq;
        const int MAX_DROPOUT = 3000;
        const int MAX_MISORDER = 100;
        const int RTP_SEQ_MOD = (1<<16);

        if(!rtp_session->rtcp_sock_output || !rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] || rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] || !rtp_session->rtcp_interval)
                return 0; /* do not process RTCP in current state */

        pkt_seq = (uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq);

        /* Detect sequence number cycle change */
        max_seq = stats->high_ext_seq_recv&0x0000ffff;
        seq_diff = pkt_seq - max_seq;

        if (seq_diff < MAX_DROPOUT) {  /* in order, with permissible gap */
                if (pkt_seq < max_seq) {
                        stats->cycle++;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rtcp_stats:[cycle change] pkt_seq[%d] cycle[%d] max_seq[%d] stats_ssrc[%u] local_ts[%u]\n",
                                        pkt_seq, stats->cycle, max_seq, stats->ssrc, rtp_session->timer.samplecount);
                }
                pkt_extended_seq = stats->cycle << 16 | pkt_seq; /* getting the extended packet extended sequence ID */
                if (pkt_extended_seq > stats->high_ext_seq_recv) {
                        stats->high_ext_seq_recv = pkt_extended_seq;
                }
        }
        else if (seq_diff <= (RTP_SEQ_MOD - MAX_MISORDER)) {   /* the sequence number made a very large jump */
                if (pkt_seq == stats->bad_seq) {
                        rtcp_stats_init(rtp_session);
                } else {
                        stats->bad_seq = (pkt_seq + 1) & (RTP_SEQ_MOD-1);
                }
                return 0; /* no stats, packet is out of sync and will be accounted as lost */
        } else {
                /* duplicate or reordered packet */
        }

        /* Verify that we are on the same stream source (we do not support multiple sources) */
        if (ntohl(hdr->ssrc) != stats->ssrc || !stats->init) {
                rtcp_stats_init(rtp_session);
        }

        stats->period_pkt_count++;
        stats->pkt_count++;
#ifdef DEBUG_RTCP
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10, "rtcp_stats: period_pkt_count[%d]last_seq[%d]cycle[%d]stats_ssrc[%u]local_ts[%u]\n",
                        stats->period_pkt_count, pkt_seq, stats->cycle, stats->ssrc, rtp_session->timer.samplecount);
#endif
        /* Interarrival jitter calculation */
        pkt_tsdiff = abs((int)rtp_session->timer.samplecount - (int)ntohl(hdr->ts));  /* relative transit times for this packet */
        if (stats->pkt_count < 2) { /* Can not compute Jitter with only one packet */
                stats->last_pkt_tsdiff = pkt_tsdiff;
        } else {
                packet_spacing_diff = abs((int)pkt_tsdiff - (int)stats->last_pkt_tsdiff);    /* Jitter : difference of relative transit times for the two packets */
                stats->last_pkt_tsdiff = pkt_tsdiff;
                /* Interarrival jitter estimation, "J(i) = J(i-1) + ( |D(i-1,i)| - J(i-1) )/16" */
                stats->inter_jitter = (stats->inter_jitter + (((double)packet_spacing_diff - stats->inter_jitter) /16.));
        }

#ifdef DEBUG_RTCP
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10, "rtcp_stats: pkt_ts[%d]local_ts[%d]diff[%d]pkt_spacing[%d]inter_jitter[%f]seq[%d]stats_ssrc[%d]",
                        ntohl(hdr->ts), rtp_session->timer.samplecount, pkt_tsdiff, packet_spacing_diff, stats->inter_jitter, ntohs(hdr->seq), stats->ssrc);
#endif
        return 1;
}

static void rtcp_stats_init ( switch_rtp_t *  rtp_session )

static

Definition at line 1816 of file switch_rtp.c.

References switch_rtcp_numbers_t::bad_seq, switch_rtcp_numbers_t::base_seq, switch_rtcp_numbers_t::cum_lost, switch_rtcp_numbers_t::cycle, switch_rtp::flags, switch_rtcp_numbers_t::high_ext_seq_recv, switch_rtcp_numbers_t::init, switch_rtcp_numbers_t::inter_jitter, switch_rtcp_numbers_t::last_pkt_tsdiff, switch_rtcp_numbers_t::last_rpt_cycle, switch_rtcp_numbers_t::last_rpt_ext_seq, switch_rtcp_numbers_t::last_rpt_ts, switch_rtp::last_rtp_hdr, switch_rtcp_numbers_t::period_pkt_count, switch_rtcp_numbers_t::pkt_count, switch_rtp::pool, switch_rtp_stats_t::rtcp, switch_rtcp_numbers_t::rtcp_rtp_count, switch_rtp::rtcp_sock_output, rtp_type, switch_timer::samplecount, switch_rtcp_numbers_t::sent_pkt_count, switch_rtcp_numbers_t::ssrc, switch_rtp::stats, SWITCH_CHANNEL_SESSION_LOG, switch_core_memory_pool_get_data(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_RTCP_PASSTHRU, and switch_rtp::timer.

Referenced by rtcp_stats(), and switch_rtp_reset().

{
        switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
        srtp_hdr_t * hdr = &rtp_session->last_rtp_hdr;
        switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
        stats->ssrc = ntohl(hdr->ssrc);
        stats->last_rpt_ts = rtp_session->timer.samplecount;
        stats->init = 1;
        stats->last_rpt_ext_seq = 0;
        stats->last_rpt_cycle = 0;
        stats->last_pkt_tsdiff = 0;
        stats->inter_jitter = 0;
        stats->cycle = 0;
        stats->high_ext_seq_recv = ntohs((uint16_t)hdr->seq);
        stats->base_seq = ntohs((uint16_t)hdr->seq);
        stats->bad_seq = (1<<16) + 1; /* Make sure we wont missmatch 2 consecutive packets, so seq == bad_seq is false */
        stats->cum_lost = 0;
        stats->period_pkt_count = 0;
        stats->sent_pkt_count = 0;
        stats->pkt_count = 0;
        stats->rtcp_rtp_count = 0;

        if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s rtcp disabled\n", rtp_type(rtp_session));
        } else if (!rtp_session->rtcp_sock_output) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "rtcp_stats_init: %s no rtcp socket\n", rtp_type(rtp_session));
        } else if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s rtcp passthru\n", rtp_type(rtp_session));
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s ssrc[%u] base_seq[%u]\n", rtp_type(rtp_session), stats->ssrc, stats->base_seq);
        }
}

static int rtp_common_read ( switch_rtp_t *  rtp_session, switch_payload_t *  payload_type, payload_map_t **  pmapP, switch_frame_flag_t *  flags, switch_io_flag_t  io_flags  )

static

Definition at line 6140 of file switch_rtp.c.

References switch_rtp_ice_t::addr, payload_map_s::allocated, switch_rtp::auto_adj_used, switch_rtp::autoadj_tally, switch_rtp::autoadj_threshold, switch_rtp::autoadj_window, switch_rtp::bad_stream, check_recv_payload(), check_rtcp_and_ice(), switch_rtp::cng_count, switch_rtp::cng_pt, do_2833(), do_flush(), do_mos(), switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, switch_rtp_rfc2833_data::dtmf_queue, switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp_numbers_t::flaws, switch_rtp::from_addr, handle_rfc2833(), switch_rtp::has_rtp, rtp_msg_t::header, rtcp_msg_t::header, switch_rtp::hot_hits, switch_rtp::ice, switch_rtp_ice_t::ice_user, if(), switch_rtp_rfc2833_data::in_digit_sanity, switch_rtp_rfc2833_data::in_digit_ts, switch_rtp_stats_t::inbound, switch_timer::interval, switch_rtp::invalid_handler, INVALID_PT, switch_rtp::jb, jb_valid(), switch_rtp::jitter_lead, JITTER_LEAD_FRAMES, switch_rtp::last_cng_ts, switch_rtp::last_read_ts, switch_rtp::last_rtp_hdr, switch_rtp::max_missed_packets, memset(), switch_rtp::missed_count, switch_rtp::ms_per_packet, payload_map_s::negotiated, payload_map_s::next, switch_rtp::one_second, switch_rtp_rfc2833_data::out_digit_dur, switch_rtp::pause_jb, switch_rtp_numbers_t::period_packet_count, switch_rtp::pmaps, process_rtcp_packet(), payload_map_s::pt, switch_rtp_stats_t::read_count, READ_DEC, READ_INC, switch_rtp::read_pollfd, read_rtcp_packet(), read_rtp_packet(), switch_rtp::recv_msg, switch_rtp::recv_te, switch_rtp::remote_addr, switch_rtp::remote_port, reset_jitter_seq(), RESULT_CONTINUE, RESULT_GOTO_END, RESULT_GOTO_RECVFROM, RESULT_GOTO_TIMERCHECK, return_cng_frame, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_read_pollfd, switch_rtp::rtcp_recv_msg, switch_rtp::rtcp_recv_msg_p, switch_rtp::rtcp_remote_addr, switch_rtp::rtcp_send_msg, switch_rtp::rtcp_sock_output, RTP_BODY, RTP_BUG_ACCEPT_ANY_PACKETS, RTP_BUG_ACCEPT_ANY_PAYLOAD, RTP_BUG_ALWAYS_AUTO_ADJUST, RTP_BUG_IGNORE_MARK_BIT, switch_rtp::rtp_bugs, rtp_flush_read_buffer(), switch_rtp::rtp_from_addr, rtp_header_len, rtp_session_name, rtp_type, switch_rtp::samples_per_interval, switch_rtp::send_ctx, switch_rtp::sending_dtmf, switch_rtp::session, SFF_CNG, SFF_NOT_AUDIO, SFF_PROXY_PACKET, SFF_RTCP, SFF_UDPTL_PACKET, switch_rtp_numbers_t::skip_packet_count, switch_rtp::sock_input, switch_rtp::srtp_idx_rtcp, switch_rtp::stats, switch_channel_get_partner_uuid(), switch_channel_get_private(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_cmp_addr(), switch_cond_next(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_core_timer_next(), switch_core_timer_sync(), SWITCH_FALSE, switch_get_addr(), SWITCH_IO_FLAG_NOBLOCK, SWITCH_IO_FLAG_SINGLE_READ, switch_jb_poll(), SWITCH_LOG_DEBUG, SWITCH_LOG_DEBUG1, SWITCH_LOG_DEBUG10, SWITCH_LOG_DEBUG3, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_poll(), switch_queue_size(), switch_rtp_clear_flag(), SWITCH_RTP_CNG_PAYLOAD, SWITCH_RTP_FLAG_AUTOADJ, SWITCH_RTP_FLAG_AUTOFLUSH, SWITCH_RTP_FLAG_BREAK, SWITCH_RTP_FLAG_DATAWAIT, SWITCH_RTP_FLAG_DTMF_ON, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_FLUSH, SWITCH_RTP_FLAG_GOOGLEHACK, SWITCH_RTP_FLAG_MUTE, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PAUSE, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RTCP_MUX, SWITCH_RTP_FLAG_RTCP_PASSTHRU, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_STICKY_FLUSH, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_FLUSH_ONCE, switch_rtp_ready(), switch_rtp_reset_media_timer(), switch_rtp_set_flag(), switch_rtp_set_remote_address(), switch_rtp_test_flag(), switch_snprintf(), switch_sockaddr_get_port(), switch_socket_sendto(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_IS_BREAK, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_strerror_r(), SWITCH_TRUE, switch_yield, switch_rtp::sync_packets, switch_rtp::timer, timer_check(), using_ice(), switch_rtp::vb, and switch_rtcp_hdr_s::version.

Referenced by switch_rtp_read(), switch_rtp_zerocopy_read(), and switch_rtp_zerocopy_read_frame().

{
        
        switch_channel_t *channel = NULL;
        switch_size_t bytes = 0;
        switch_size_t rtcp_bytes = 0;
        switch_status_t status = SWITCH_STATUS_SUCCESS, poll_status = SWITCH_STATUS_SUCCESS;
        switch_status_t rtcp_status = SWITCH_STATUS_SUCCESS, rtcp_poll_status = SWITCH_STATUS_SUCCESS;
        int check = 0;
        int ret = -1;
        int sleep_mss = 1000;
        int poll_sec = 5;
        int poll_loop = 0;
        int fdr = 0;
        int rtcp_fdr = 0;
        int hot_socket = 0;
        int read_loops = 0;
        int slept = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return -1;
        }

        if (rtp_session->session) {
                channel = switch_core_session_get_channel(rtp_session->session);
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                sleep_mss = rtp_session->timer.interval * 1000;
        }

        READ_INC(rtp_session);



        while (switch_rtp_ready(rtp_session)) {
                int do_cng = 0;
                int read_pretriggered = 0;
                int has_rtcp = 0;
                int got_rtp_poll = 0;

                bytes = 0;

                if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] &&
                        !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && 
                        !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && 
                        !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
                        rtp_session->read_pollfd) {
                        
                        if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
                                while (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
                                        status = read_rtp_packet(rtp_session, &bytes, flags, SWITCH_STATUS_SUCCESS, SWITCH_FALSE);

                                        if (status == SWITCH_STATUS_GENERR) {
                                                ret = -1;
                                                goto end;
                                        }

                                        if ((*flags & SFF_RTCP)) {
                                                *flags &= ~SFF_RTCP;
                                                has_rtcp = 1;
                                                read_pretriggered = 0;
                                                goto rtcp;
                                        }

                                        if (status == SWITCH_STATUS_BREAK) {
                                                read_pretriggered = 1;
                                                break;
                                        }
                                }
                                
                        } else if ((rtp_session->flags[SWITCH_RTP_FLAG_AUTOFLUSH] || rtp_session->flags[SWITCH_RTP_FLAG_STICKY_FLUSH])) {
                                
                                if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
                                        status = read_rtp_packet(rtp_session, &bytes, flags, SWITCH_STATUS_SUCCESS, SWITCH_FALSE);
                                        if (status == SWITCH_STATUS_GENERR) {
                                                ret = -1;
                                                goto end;
                                        }
                                        if ((*flags & SFF_RTCP)) {
                                                *flags &= ~SFF_RTCP;
                                                has_rtcp = 1;
                                                read_pretriggered = 0;
                                                goto rtcp;
                                        }

                                        /* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Initial (%i) %d\n", status, bytes); */
                                        if (status != SWITCH_STATUS_FALSE) {
                                                read_pretriggered = 1;
                                        }

                                        if (bytes) {
                                                if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
                                                        rtp_session->hot_hits++;//+= rtp_session->samples_per_interval;
                                                        
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG10, "%s Hot Hit %d\n", 
                                                                                          rtp_session_name(rtp_session),
                                                                                          rtp_session->hot_hits); 
                                                } else {
                                                        rtp_session->hot_hits = 0;
                                                }
                                        }
                                        
                                        if (rtp_session->hot_hits > 1 && !rtp_session->sync_packets) {// >= (rtp_session->samples_per_second * 30)) {
                                                hot_socket = 1;
                                        }
                                } else {
                                        rtp_session->hot_hits = 0;
                                }
                        }

                        if (hot_socket && (rtp_session->hot_hits % 10) != 0) { 
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG10, "%s timer while HOT\n", rtp_session_name(rtp_session));
                                switch_core_timer_next(&rtp_session->timer);
                        } else if (hot_socket) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG10, "%s skip timer once\n", rtp_session_name(rtp_session));
                                rtp_session->sync_packets++;
                                switch_core_timer_sync(&rtp_session->timer);
                                reset_jitter_seq(rtp_session);
                        } else {
                                
                                if (rtp_session->sync_packets) {

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG10,
                                                                          "%s Auto-Flush catching up %d packets (%d)ms.\n",
                                                                          rtp_session_name(rtp_session),
                                                                          rtp_session->sync_packets, (rtp_session->ms_per_packet * rtp_session->sync_packets) / 1000);
                                        if (!rtp_session->flags[SWITCH_RTP_FLAG_PAUSE]) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG3, "%s syncing %d %s packet(s)\n", 
                                                                                 rtp_session_name(rtp_session),
                                                                                  rtp_session->sync_packets, rtp_type(rtp_session));

                                                rtp_session->bad_stream++;
                                                rtp_session->stats.inbound.flaws += rtp_session->sync_packets;
                                        }

                                        switch_core_timer_sync(&rtp_session->timer);
                                        reset_jitter_seq(rtp_session);
                                        rtp_session->hot_hits = 0;
                                } else {
                                        if (slept) {
                                                switch_cond_next();
                                        } else {
                                                switch_core_timer_next(&rtp_session->timer);
                                                slept++;
                                        }

                                }
                                
                                rtp_session->sync_packets = 0;
                        }
                }

                rtp_session->stats.read_count++;

        recvfrom:

                if (!read_pretriggered) {
                        bytes = 0;
                }
                read_loops++;
                //poll_loop = 0;

                if (!switch_rtp_ready(rtp_session)) {
                        break;
                }
                
                if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->read_pollfd) {
                        int pt = poll_sec * 1000000;

                        do_2833(rtp_session);

                        if (rtp_session->dtmf_data.out_digit_dur > 0 || rtp_session->dtmf_data.in_digit_sanity || rtp_session->sending_dtmf || 
                                switch_queue_size(rtp_session->dtmf_data.dtmf_queue) || switch_queue_size(rtp_session->dtmf_data.dtmf_inqueue)) {
                                pt = 20000;
                        }
                        
                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                                pt = 200000;
                        }

                        if (rtp_session->vb) {
                                if (switch_jb_poll(rtp_session->vb)) {
                                        pt = 0;
                                }
                        }

                        if ((io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
                                pt = 0;
                        }
                        
                        poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, pt);


                        //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF Poll %d\n", poll_status);
                        //}
                        
                        if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->dtmf_data.out_digit_dur > 0) {
                                return_cng_frame();
                        }

                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->flags[SWITCH_RTP_FLAG_BREAK]) {
                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_BREAK);
                                bytes = 0;
                                reset_jitter_seq(rtp_session);
                                return_cng_frame();
                        }

                }
                
                        
                if (poll_status == SWITCH_STATUS_SUCCESS || (rtp_session->vb && switch_jb_poll(rtp_session->vb))) {

                        got_rtp_poll = 1;

                        if (read_pretriggered) {
                                read_pretriggered = 0;
                        } else {

                                status = read_rtp_packet(rtp_session, &bytes, flags, poll_status, SWITCH_TRUE);

                                if (status == SWITCH_STATUS_GENERR) {
                                        ret = -1;
                                        goto end;
                                }

                                if (rtp_session->max_missed_packets && read_loops == 1 && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && 
                                        !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
                                        if (bytes && status == SWITCH_STATUS_SUCCESS) {
                                                rtp_session->missed_count = 0;
                                        } else if (++rtp_session->missed_count >= rtp_session->max_missed_packets) {
                                                ret = -2;
                                                goto end;
                                        }
                                }
                                
                                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                                        //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "Read bytes (%i) %ld\n", status, bytes); 
                                        
                                        if (bytes == 0) {
                                                if (check_rtcp_and_ice(rtp_session) == -1) {
                                                        ret = -1;
                                                        goto end;
                                                }
                                                // This is dumb
                                                //switch_rtp_video_refresh(rtp_session);
                                                goto  rtcp;
                                        }
                                }

                                if ((*flags & SFF_PROXY_PACKET)) {
                                        ret = (int) bytes;
                                        goto end;
                                }

                                if ((*flags & SFF_RTCP)) {
                                        *flags &= ~SFF_RTCP;
                                        has_rtcp = 1;
                                        goto rtcp;
                                }


                        }
                        poll_loop = 0;
                } else {

                        if (!switch_rtp_ready(rtp_session)) {
                                ret = -1;
                                goto end;
                        }
                        
                        if (!SWITCH_STATUS_IS_BREAK(poll_status) && poll_status != SWITCH_STATUS_TIMEOUT) {
                                char tmp[128] = "";
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Poll failed with error: %d [%s]\n",
                                                                  poll_status, switch_strerror_r(poll_status, tmp, sizeof(tmp)));
                                ret = -1;
                                goto end;
                        }

                        if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                                rtp_session->missed_count += (poll_sec * 1000) / (rtp_session->ms_per_packet ? rtp_session->ms_per_packet / 1000 : 20);
                                bytes = 0;

                                if (rtp_session->max_missed_packets) {
                                        if (rtp_session->missed_count >= rtp_session->max_missed_packets) {
                                                ret = -2;
                                                goto end;
                                        }
                                }
                        }


                        if (check_rtcp_and_ice(rtp_session) == -1) {
                                ret = -1;
                                goto end;
                        }
                        
                        
                        if ((!(io_flags & SWITCH_IO_FLAG_NOBLOCK)) && 
                                (rtp_session->dtmf_data.out_digit_dur == 0) && !rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                                return_cng_frame();
                        }
                }
                
        rtcp:

                if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                        rtcp_poll_status = SWITCH_STATUS_FALSE;
                        
                        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX] && has_rtcp) {
                                if (rtp_session->rtcp_recv_msg_p->header.version == 2) { //rtcp muxed
                                        rtp_session->rtcp_from_addr = rtp_session->from_addr;
                                        rtcp_status = rtcp_poll_status = SWITCH_STATUS_SUCCESS;
                                        rtcp_bytes = bytes;
                                }

                                has_rtcp = 0;
                                
                        } else if (rtp_session->rtcp_read_pollfd) {
                                rtcp_poll_status = switch_poll(rtp_session->rtcp_read_pollfd, 1, &rtcp_fdr, 0);
                        }
                                                
                        if (rtcp_poll_status == SWITCH_STATUS_SUCCESS) {
                                
                                if (!rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                                        rtcp_status = read_rtcp_packet(rtp_session, &rtcp_bytes, flags);
                                }
                                
                                if (rtcp_status == SWITCH_STATUS_SUCCESS) {
                                        switch_rtp_reset_media_timer(rtp_session);
                                        
                                        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {
                                                switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
                                                const char *uuid = switch_channel_get_partner_uuid(channel);

                                                if (uuid) {
                                                        switch_core_session_t *other_session;
                                                        switch_rtp_t *other_rtp_session = NULL;

                                                        if ((other_session = switch_core_session_locate(uuid))) {
                                                                switch_channel_t *other_channel = switch_core_session_get_channel(other_session);                                       
                                                                if ((other_rtp_session = switch_channel_get_private(other_channel, "__rtcp_audio_rtp_session")) && 
                                                                        other_rtp_session->rtcp_sock_output &&
                                                                        switch_rtp_test_flag(other_rtp_session, SWITCH_RTP_FLAG_ENABLE_RTCP)) {
                                                                        other_rtp_session->rtcp_send_msg = rtp_session->rtcp_recv_msg;
                                                                        
#ifdef ENABLE_SRTP
                                                                        if (switch_rtp_test_flag(other_rtp_session, SWITCH_RTP_FLAG_SECURE_SEND)) {
                                                                                int sbytes = (int) rtcp_bytes;
                                                                                int stat = srtp_protect_rtcp(other_rtp_session->send_ctx[rtp_session->srtp_idx_rtcp], &other_rtp_session->rtcp_send_msg.header, &sbytes);
                                                                                if (stat) {
                                                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP RTCP protection failed with code %d\n", stat);
                                                                                }
                                                                                rtcp_bytes = sbytes;

                                                                        }
#endif

#ifdef ENABLE_ZRTP
                                                                        /* ZRTP Send */
                                                                        if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                                                                                unsigned int sbytes = (unsigned int) bytes;
                                                                                zrtp_status_t stat = zrtp_status_fail;
                                                                        
                                                                                stat = zrtp_process_rtcp(other_rtp_session->zrtp_stream, (void *) &other_rtp_session->rtcp_send_msg, &sbytes);
                                                                        
                                                                                switch (stat) {
                                                                                case zrtp_status_ok:
                                                                                        break;
                                                                                case zrtp_status_drop:
                                                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
                                                                                        ret = (int) bytes;
                                                                                        goto end;
                                                                                        break;
                                                                                case zrtp_status_fail:
                                                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                                                                        break;
                                                                                default:
                                                                                        break;
                                                                                }
                                                                        
                                                                                bytes = sbytes;
                                                                        }
#endif
                                                                        if (switch_socket_sendto(other_rtp_session->rtcp_sock_output, other_rtp_session->rtcp_remote_addr, 0, 
                                                                                                                         (const char*)&other_rtp_session->rtcp_send_msg, &rtcp_bytes ) != SWITCH_STATUS_SUCCESS) {
                                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG,"RTCP packet not written\n");
                                                                        }
                                                                
                                                                
                                                                }
                                                                switch_core_session_rwunlock(other_session);
                                                        }
                                                }
                                        
                                        }

                                        if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                                                process_rtcp_packet(rtp_session, &rtcp_bytes);
                                                ret = 1;
                                        
                                                if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
                                                        switch_core_timer_sync(&rtp_session->timer);
                                                        reset_jitter_seq(rtp_session);
                                                }
                                                goto recvfrom;
                                        }
                                }
                        }
                }

                if ((!(io_flags & SWITCH_IO_FLAG_NOBLOCK)) && 
                        (rtp_session->dtmf_data.out_digit_dur == 0) && !got_rtp_poll) {
                        return_cng_frame();
                }


                if (bytes && rtp_session->has_rtp && 
                        !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
                        rtp_session->last_rtp_hdr.pt != 13 && 
                        rtp_session->last_rtp_hdr.pt != rtp_session->recv_te && 
                        rtp_session->last_rtp_hdr.pt != rtp_session->cng_pt) {
                        int accept_packet = 1;
                        

                        if (rtp_session->pmaps && *rtp_session->pmaps) {
                                payload_map_t *pmap;
                                accept_packet = 0;

                                switch_mutex_lock(rtp_session->flag_mutex);
                                for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {                                  
                                        
                                        if (!pmap->negotiated) {
                                                continue;
                                        }

                                        if (rtp_session->last_rtp_hdr.pt == pmap->pt) {
                                                accept_packet = 1;
                                                if (pmapP) {
                                                        *pmapP = pmap;
                                                }
                                                break;
                                        }
                                }
                                switch_mutex_unlock(rtp_session->flag_mutex);
                        }
                        
                        if (!accept_packet &&
                                !(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PAYLOAD) && !(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PACKETS)) {
                                /* drop frames of incorrect payload number and return CNG frame instead */

                                return_cng_frame();
                        }
                }

                if (!bytes && (io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
                        rtp_session->missed_count = 0;
                        ret = 0;
                        goto end;
                }

                check = !bytes;

                if (rtp_session->flags[SWITCH_RTP_FLAG_FLUSH]) {
                        bytes = do_flush(rtp_session, SWITCH_FALSE, bytes);
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
                }
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_BREAK] || (bytes && bytes == 4 && *((int *) &rtp_session->recv_msg) == UINT_MAX)) {
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_BREAK);

                        if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] || !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] || 
                                rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] || 
                                (bytes && bytes < 5) || (!bytes && poll_loop)) {
                                bytes = 0;
                                reset_jitter_seq(rtp_session);
                                return_cng_frame();
                        }
                }

                if (bytes && bytes < 5) {
                        continue;
                }

                if (!bytes && poll_loop) {
                        goto recvfrom;
                }

                if (bytes && rtp_session->last_rtp_hdr.m && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te && 
                        !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
                        !(rtp_session->rtp_bugs & RTP_BUG_IGNORE_MARK_BIT)) {
                        rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);
                }


                if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
                        *flags |= SFF_NOT_AUDIO;
                } else {
                        *flags &= ~SFF_NOT_AUDIO; /* If this flag was already set, make sure to remove it when we get real audio */
                }

                /* ignore packets not meant for us unless the auto-adjust window is open (ice mode has its own alternatives to this) */
                if (!using_ice(rtp_session) && bytes) {
                        if (rtp_session->flags[SWITCH_RTP_FLAG_AUTOADJ]) {
                                if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
                                        goto recvfrom;

                                }
                        } else if (!(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PACKETS) && !switch_cmp_addr(rtp_session->rtp_from_addr, rtp_session->remote_addr)) {
                                goto recvfrom;
                        }
                }

                if (bytes && rtp_session->flags[SWITCH_RTP_FLAG_AUTOADJ] && switch_sockaddr_get_port(rtp_session->rtp_from_addr)) {
                        if (!switch_cmp_addr(rtp_session->rtp_from_addr, rtp_session->remote_addr)) {
                                if (++rtp_session->autoadj_tally >= rtp_session->autoadj_threshold) {
                                        const char *err;
                                        uint32_t old = rtp_session->remote_port;
                                        const char *tx_host;
                                        const char *old_host;
                                        char bufa[50], bufb[50];
                                        char adj_port[6];

                                        tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
                                        old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO,
                                                                          "Auto Changing %s port from %s:%u to %s:%u\n", rtp_type(rtp_session), old_host, old, tx_host,
                                                                          switch_sockaddr_get_port(rtp_session->rtp_from_addr));

                                        if (channel) {
                                                char varname[80] = "";

                                                switch_snprintf(varname, sizeof(varname), "remote_%s_ip_reported", rtp_type(rtp_session));
                                                switch_channel_set_variable(channel, varname, switch_channel_get_variable(channel, "remote_media_ip"));

                                                switch_snprintf(varname, sizeof(varname), "remote_%s_ip", rtp_type(rtp_session));
                                                switch_channel_set_variable(channel, varname, tx_host);

                                                switch_snprintf(varname, sizeof(varname), "remote_%s_port_reported", rtp_type(rtp_session));
                                                switch_snprintf(adj_port, sizeof(adj_port), "%u", switch_sockaddr_get_port(rtp_session->rtp_from_addr));
                                                switch_channel_set_variable(channel, varname, switch_channel_get_variable(channel, "remote_media_port"));

                                                switch_snprintf(varname, sizeof(varname), "remote_%s_port", rtp_type(rtp_session));
                                                switch_channel_set_variable(channel, varname, adj_port);

                                                switch_snprintf(varname, sizeof(varname), "rtp_auto_adjust_%s", rtp_type(rtp_session));
                                                switch_channel_set_variable(channel, varname, "true");
                                        }
                                        rtp_session->auto_adj_used = 1;
                                        switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr), 0, SWITCH_FALSE, &err);
                                        if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
                                                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                        } else {
                                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                        }
                                        if (rtp_session->ice.ice_user) {
                                                rtp_session->ice.addr = rtp_session->remote_addr;
                                        }
                                }
                        } else {
                                if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
                                        switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Correct %s ip/port confirmed.\n", rtp_type(rtp_session));
                                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                }
                                rtp_session->auto_adj_used = 0;
                        }
                }

                if (bytes && !(rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST) && rtp_session->autoadj_window) {
                        if (--rtp_session->autoadj_window == 0) {
                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        }
                }

                if (bytes && (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL])) {
                        /* Fast PASS! */
                        *flags |= SFF_PROXY_PACKET;

                        if (rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
#if 0
                                if (rtp_session->has_rtp && check_recv_payload(rtp_session)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, 
                                                                          "Ignoring udptl packet of size of %ld bytes that looks strikingly like a RTP packet.\n", (long)bytes);
                                        bytes = 0;
                                        goto do_continue;                                       
                                }
#endif
                                *flags |= SFF_UDPTL_PACKET;
                        }

                        ret = (int) bytes;
                        goto end;
                }

                if (bytes) {
                        rtp_session->missed_count = 0;

                        if (bytes < rtp_header_len) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "Ignoring invalid RTP packet size of %ld bytes.\n", (long)bytes);
                                bytes = 0;
                                goto do_continue;
                        }
                        
                        if (rtp_session->last_rtp_hdr.pt && (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13)) {
                                return_cng_frame();
                        }
                }

                if (check || bytes) {
                        do_2833(rtp_session);
                }

                if (bytes && rtp_session->recv_msg.header.version != 2) {
                        uint8_t *data = (uint8_t *) RTP_BODY(rtp_session);

                        //if (rtp_session->recv_msg.header.version == 0) {
                        //      if (rtp_session->ice.ice_user) {
                        //              handle_ice(rtp_session, &rtp_session->ice, (void *) &rtp_session->recv_msg, bytes);
                        //              goto recvfrom;
                        //      }
                        //}

                        if (rtp_session->invalid_handler) {
                                rtp_session->invalid_handler(rtp_session, rtp_session->sock_input, (void *) &rtp_session->recv_msg, bytes, rtp_session->rtp_from_addr);
                        }

                        memset(data, 0, 2);
                        data[0] = 65;

                        rtp_session->last_rtp_hdr.pt = rtp_session->cng_pt != INVALID_PT ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
                        *flags |= SFF_CNG;
                        *payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;
                        ret = 2 + rtp_header_len;
                        goto end;
                } else if (bytes) {
                        rtp_session->stats.inbound.period_packet_count++;
                }


                /* Handle incoming RFC2833 packets */
                switch (handle_rfc2833(rtp_session, bytes, &do_cng)) {
                case RESULT_GOTO_END:
                        goto end;
                case RESULT_GOTO_RECVFROM:
                        goto recvfrom;
                case RESULT_GOTO_TIMERCHECK:
                        goto timer_check;
                case RESULT_CONTINUE:
                        status = SWITCH_STATUS_SUCCESS;
                        goto result_continue;
                }

        result_continue:
        timer_check:
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_MUTE]) {
                        do_cng++;
                }

                if (do_cng) {
                        uint8_t *data = (uint8_t *) RTP_BODY(rtp_session);

                        do_2833(rtp_session);

                        if (rtp_session->last_cng_ts == rtp_session->last_read_ts + rtp_session->samples_per_interval) {
                                rtp_session->last_cng_ts = 0;
                        } else {
                                rtp_session->last_cng_ts = rtp_session->last_read_ts + rtp_session->samples_per_interval;
                        }

                        memset(data, 0, 2);
                        data[0] = 65;
                        rtp_session->last_rtp_hdr.pt = rtp_session->cng_pt != INVALID_PT ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD;
                        *flags |= SFF_CNG;
                        *payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;
                        ret = 2 + rtp_header_len;
                        rtp_session->stats.inbound.skip_packet_count++;
                        goto end;
                }


                if (check || (bytes && !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER])) {
                        if (!bytes && rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {  /* We're late! We're Late! */
                                if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] && status == SWITCH_STATUS_BREAK) {
                                        switch_cond_next();
                                        continue;
                                }

                                

                                if (!rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] && !rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] && !rtp_session->dtmf_data.in_digit_ts 
                                        && rtp_session->cng_count > (rtp_session->one_second * 2) && rtp_session->jitter_lead > JITTER_LEAD_FRAMES) {

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG1, "%s %s timeout\n", 
                                                                          rtp_session_name(rtp_session), rtp_type(rtp_session));

                                        rtp_session->stats.inbound.flaws++;
                                        do_mos(rtp_session, SWITCH_FALSE);
                                }

                                rtp_session->cng_count++;
                                return_cng_frame();
                        }
                }

                rtp_session->cng_count = 0;

                if (status == SWITCH_STATUS_BREAK || bytes == 0) {
                        if (!(io_flags & SWITCH_IO_FLAG_SINGLE_READ) && rtp_session->flags[SWITCH_RTP_FLAG_DATAWAIT]) {
                                goto do_continue;
                        }
                        return_cng_frame();
                }

                if (rtp_session->flags[SWITCH_RTP_FLAG_GOOGLEHACK] && rtp_session->last_rtp_hdr.pt == 102) {
                        rtp_session->last_rtp_hdr.pt = 97;
                }

                break;

        do_continue:

                if (!bytes && !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                        switch_yield(sleep_mss);
                }

        }

        if (switch_rtp_ready(rtp_session)) {
                *payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;

                if (*payload_type == SWITCH_RTP_CNG_PAYLOAD) {
                        *flags |= SFF_CNG;
                }

                ret = (int) bytes;
        } else {
                ret = -1;
        }

 end:

        READ_DEC(rtp_session);

        return ret;
}

static int rtp_common_write ( switch_rtp_t *  rtp_session, rtp_msg_t *  send_msg, void *  data, uint32_t  datalen, switch_payload_t  payload, uint32_t  timestamp, switch_frame_flag_t *  flags  )

static

Definition at line 7183 of file switch_rtp.c.

References switch_codec_implementation::actual_samples_per_second, switch_rtp_vad_data::bg_count, switch_rtp_vad_data::bg_len, switch_rtp_vad_data::bg_level, rtp_msg_t::body, switch_rtp::cn, switch_rtp_vad_data::cng_count, switch_rtp_numbers_t::cng_packet_count, switch_rtp::cng_pt, switch_rtp::delay_samples, ts_normalize_s::delta, ts_normalize_s::delta_ct, ts_normalize_s::delta_ttl, switch_rtp_vad_data::diff_level, switch_rtp_vad_data::fire_events, switch_rtp::flags, get_next_write_ts(), switch_rtp_vad_data::hangover, switch_rtp_vad_data::hangover_hits, switch_rtp_vad_data::hangunder, switch_rtp_vad_data::hangunder_hits, rtp_msg_t::header, switch_codec_implementation::ianacode, switch_codec::implementation, INVALID_PT, ts_normalize_s::last_frame, switch_rtp::last_rtp_hdr, ts_normalize_s::last_ssrc, switch_rtp::last_write_samplecount, switch_rtp::last_write_timestamp, switch_rtp::last_write_ts, switch_rtp::local_addr, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, switch_rtp::ms_per_packet, switch_rtp::need_mark, switch_rtp_vad_data::next_scan, switch_codec_implementation::number_of_channels, switch_rtp::one_second, switch_rtp_stats_t::outbound, switch_rtp_numbers_t::packet_count, switch_rtp::payload, switch_rtp::pool, switch_rtp::queue_delay, switch_rtp_numbers_t::raw_bytes, switch_rtp_vad_data::read_codec, switch_rtp::remote_addr, switch_rtp::remote_port, switch_rtp_stats_t::rtcp, RTP_BUG_CHANGE_SSRC_ON_MARKER, RTP_BUG_NEVER_SEND_MARKER, switch_rtp::rtp_bugs, switch_rtp::rtp_from_addr, rtp_header_len, rtp_type, rtp_write_ready(), switch_timer::samplecount, switch_rtp::samples_per_interval, switch_rtp_vad_data::scan_freq, switch_rtp::send_ctx, switch_rtp::send_msg, switch_rtp::send_policy, switch_rtp::send_time, switch_rtp::sending_dtmf, switch_rtcp_numbers_t::sent_pkt_count, switch_rtp::seq, switch_rtp_vad_data::session, switch_rtp::session, SFF_RFC2833, SJB_QUEUE_ONLY, SJB_VIDEO, switch_rtp::sock_output, switch_rtp::srtp_idx_rtp, switch_rtp::ssrc, switch_rtp_vad_data::start, switch_rtp_vad_data::start_count, switch_rtp_vad_data::start_talking, switch_rtp::stats, switch_rtp_vad_data::stop_talking, switch_channel_event_set_data(), switch_channel_get_name(), SWITCH_CHANNEL_LOG, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CHANNEL_SESSION_LOG_CLEAN, switch_clear_flag, switch_core_codec_decode(), switch_core_session_get_channel(), switch_core_timer_sync(), switch_epoch_time_now(), switch_event_create, switch_event_fire, SWITCH_EVENT_NOTALK, SWITCH_EVENT_TALK, switch_get_addr(), switch_jb_create(), switch_jb_put_packet(), switch_jb_set_flag(), SWITCH_LOG_ALERT, SWITCH_LOG_CONSOLE, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), switch_micro_time_now(), SWITCH_RECOMMENDED_BUFFER_SIZE, switch_rtp_clear_flag(), SWITCH_RTP_FLAG_BYTESWAP, SWITCH_RTP_FLAG_DEBUG_RTP_WRITE, SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_GEN_TS_DELTA, SWITCH_RTP_FLAG_GOOGLEHACK, SWITCH_RTP_FLAG_NACK, SWITCH_RTP_FLAG_PAUSE, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_RESET, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SECURE_SEND_RESET, SWITCH_RTP_FLAG_UDPTL, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VAD, SWITCH_RTP_FLAG_VIDEO, switch_rtp_ready(), switch_rtp_set_ssrc(), switch_rtp_test_flag(), switch_set_flag, switch_sockaddr_get_port(), switch_socket_sendto(), SWITCH_STATUS_SUCCESS, switch_swap_linear(), switch_test_flag, switch_time_now(), SWITCH_VAD_FLAG_EVENTS_NOTALK, SWITCH_VAD_FLAG_EVENTS_TALK, SWITCH_VAD_FLAG_TALKING, switch_rtp::te, switch_rtp::timer, switch_rtp_vad_data::total_talk_time, ts_normalize_s::ts, switch_rtp::ts, switch_rtp::ts_norm, switch_rtp_vad_data::vad_codec, switch_rtp::vad_data, VAD_FIRE_NOT_TALK, VAD_FIRE_TALK, switch_rtp::vbw, WRITE_DEC, and WRITE_INC.

Referenced by switch_rtp_write_frame().

{
        switch_size_t bytes;
        uint8_t send = 1;
        uint32_t this_ts = 0;
        int ret;
        switch_time_t now;
        uint8_t m = 0;

        if (!switch_rtp_ready(rtp_session)) {
                return -1;
        }

        if (!rtp_write_ready(rtp_session, datalen, __LINE__)) {
                return 0;
        }

        WRITE_INC(rtp_session);

        if (send_msg) {
                bytes = datalen;

                m = (uint8_t) send_msg->header.m;
                rtp_session->ts = ntohl(send_msg->header.ts);

                if (flags && *flags & SFF_RFC2833) {
                        if (rtp_session->te == INVALID_PT) {
                                ret = 0;
                                goto end;
                        }
                        send_msg->header.pt = rtp_session->te;
                }
                data = send_msg->body;
                if (datalen > rtp_header_len) {
                        datalen -= rtp_header_len;
                }
        } else {
                if (*flags & SFF_RFC2833) {
                        if (rtp_session->te == INVALID_PT) {
                                ret = 0;
                                goto end;
                        }
                        payload = rtp_session->te;
                }

                send_msg = &rtp_session->send_msg;
                send_msg->header.pt = payload;

                m = get_next_write_ts(rtp_session, timestamp);

                rtp_session->send_msg.header.ts = htonl(rtp_session->ts);

                memcpy(send_msg->body, data, datalen);
                bytes = datalen + rtp_header_len;
        }

        if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {

                if ((rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
                        m = 0;
                } else {
                        if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
                                ((!rtp_session->flags[SWITCH_RTP_FLAG_RESET] && (rtp_session->ts - rtp_session->last_write_ts > rtp_session->samples_per_interval * 10))
                                || rtp_session->ts == rtp_session->samples_per_interval)) {
                                m++;
                        }
                        
                        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && 
                                (rtp_session->timer.samplecount - rtp_session->last_write_samplecount) > rtp_session->samples_per_interval * 10) {
                                m++;
                        }
                        
                        if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] &&
                                ((unsigned) ((switch_micro_time_now() - rtp_session->last_write_timestamp))) > (rtp_session->ms_per_packet * 10)) {
                                m++;
                        }
                        
                        if (rtp_session->cn && payload != rtp_session->cng_pt) {
                                rtp_session->cn = 0;
                                m++;
                        }
                        
                        if (rtp_session->need_mark && !rtp_session->sending_dtmf) {
                                m++;
                                rtp_session->need_mark = 0;
                        }
                }

                if (m) {
                        rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
                        rtp_session->ts = 0;
                }
        
                /* If the marker was set, and the timestamp seems to have started over - set a new SSRC, to indicate this is a new stream */
                if (m && !switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND) && (rtp_session->rtp_bugs & RTP_BUG_CHANGE_SSRC_ON_MARKER) && 
                        (rtp_session->flags[SWITCH_RTP_FLAG_RESET] || (rtp_session->ts <= rtp_session->last_write_ts && rtp_session->last_write_ts > 0))) {
                        switch_rtp_set_ssrc(rtp_session, (uint32_t) ((intptr_t) rtp_session + (uint32_t) switch_epoch_time_now(NULL)));
                }
                
                if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO) && !switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_UDPTL)) {
                        send_msg->header.m = (m && !(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) ? 1 : 0;
                }
        }


        if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_GEN_TS_DELTA) || switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
                /* Normalize the timestamps to our own base by generating a made up starting point then adding the measured deltas to that base 
                   so if the timestamps and ssrc of the source change, it will not break the other end's jitter bufffer / decoder etc *cough* CHROME *cough*
                 */

                if (!rtp_session->ts_norm.ts) {
                        if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_GEN_TS_DELTA)) {
                                rtp_session->ts_norm.ts = (uint32_t) rand() % 1000000 + 1;
                        } else {
                                switch_core_timer_sync(&rtp_session->timer);
                                rtp_session->ts_norm.ts = rtp_session->timer.samplecount;
                        }
                }

                if (!rtp_session->ts_norm.last_ssrc || send_msg->header.ssrc != rtp_session->ts_norm.last_ssrc) {
                        if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_GEN_TS_DELTA)) {
                                if (rtp_session->ts_norm.last_ssrc) {
                                        rtp_session->ts_norm.delta_ct = 1;
                                        rtp_session->ts_norm.delta_ttl = 0;
                                        if (rtp_session->ts_norm.delta) {
                                                rtp_session->ts_norm.ts += rtp_session->ts_norm.delta;
                                        }
                                }
                        }

                        rtp_session->ts_norm.last_ssrc = send_msg->header.ssrc;
                        rtp_session->ts_norm.last_frame = ntohl(send_msg->header.ts);
                }
                

                if (ntohl(send_msg->header.ts) != rtp_session->ts_norm.last_frame) {
                        if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_GEN_TS_DELTA)) {
                                int32_t delta = (int32_t) (ntohl(send_msg->header.ts) - rtp_session->ts_norm.last_frame);
                        
                                if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO) && delta > 0 && delta < 90000) {
                                        rtp_session->ts_norm.delta = delta;
                                }
                                
                                rtp_session->ts_norm.ts += rtp_session->ts_norm.delta;
                        } else {
                                switch_core_timer_sync(&rtp_session->timer);
                                rtp_session->ts_norm.ts = rtp_session->timer.samplecount;
                        }
                }
                
                rtp_session->ts_norm.last_frame = ntohl(send_msg->header.ts);
                send_msg->header.ts = htonl(rtp_session->ts_norm.ts);
        }

        send_msg->header.ssrc = htonl(rtp_session->ssrc);

        if (rtp_session->flags[SWITCH_RTP_FLAG_GOOGLEHACK] && rtp_session->send_msg.header.pt == 97) {
                rtp_session->last_rtp_hdr.pt = 102;
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_VAD] &&
                rtp_session->last_rtp_hdr.pt == rtp_session->vad_data.read_codec->implementation->ianacode) {

                int16_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE / sizeof(int16_t)] = { 0 };
                uint32_t rate = 0;
                uint32_t codec_flags = 0;
                uint32_t len = sizeof(decoded);
                time_t now = switch_epoch_time_now(NULL);
                send = 0;
                
                if (rtp_session->vad_data.scan_freq && rtp_session->vad_data.next_scan <= now) {
                        rtp_session->vad_data.bg_count = rtp_session->vad_data.bg_level = 0;
                        rtp_session->vad_data.next_scan = now + rtp_session->vad_data.scan_freq;
                }

                if (switch_core_codec_decode(&rtp_session->vad_data.vad_codec,
                                                                         rtp_session->vad_data.read_codec,
                                                                         data,
                                                                         datalen,
                                                                         rtp_session->vad_data.read_codec->implementation->actual_samples_per_second,
                                                                         decoded, &len, &rate, &codec_flags) == SWITCH_STATUS_SUCCESS) {

                        uint32_t energy = 0;
                        uint32_t x, y = 0, z = len / sizeof(int16_t);
                        uint32_t score = 0;
                        int divisor = 0;
                        if (z) {

                                if (!(divisor = rtp_session->vad_data.read_codec->implementation->actual_samples_per_second / 8000)) {
                                        divisor = 1;
                                }

                                for (x = 0; x < z; x++) {
                                        energy += abs(decoded[y]);
                                        y += rtp_session->vad_data.read_codec->implementation->number_of_channels;
                                }

                                if (++rtp_session->vad_data.start_count < rtp_session->vad_data.start) {
                                        send = 1;
                                } else {
                                        score = (energy / (z / divisor));
                                        if (score && (rtp_session->vad_data.bg_count < rtp_session->vad_data.bg_len)) {
                                                rtp_session->vad_data.bg_level += score;
                                                if (++rtp_session->vad_data.bg_count == rtp_session->vad_data.bg_len) {
                                                        rtp_session->vad_data.bg_level /= rtp_session->vad_data.bg_len;
                                                }
                                                send = 1;
                                        } else {
                                                if (score > rtp_session->vad_data.bg_level && !switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
                                                        uint32_t diff = score - rtp_session->vad_data.bg_level;
                                                        
                                                        if (rtp_session->vad_data.hangover_hits) {
                                                                rtp_session->vad_data.hangover_hits--;
                                                        }

                                                        if (diff >= rtp_session->vad_data.diff_level || ++rtp_session->vad_data.hangunder_hits >= rtp_session->vad_data.hangunder) {

                                                                switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);

                                                                rtp_session->vad_data.start_talking = switch_time_now();

                                                                if (!(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
                                                                        send_msg->header.m = 1;
                                                                }
                                                                rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
                                                                if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)) {

                                                                        if ((rtp_session->vad_data.fire_events & VAD_FIRE_TALK)) {
                                                                                switch_event_t *event;
                                                                                if (switch_event_create(&event, SWITCH_EVENT_TALK) == SWITCH_STATUS_SUCCESS) {
                                                                                        switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
                                                                                        switch_event_fire(&event);
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                } else {
                                                        if (rtp_session->vad_data.hangunder_hits) {
                                                                rtp_session->vad_data.hangunder_hits--;
                                                        }
                                                        if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
                                                                if (++rtp_session->vad_data.hangover_hits >= rtp_session->vad_data.hangover) {
                                                                        rtp_session->vad_data.stop_talking = switch_time_now();
                                                                        rtp_session->vad_data.total_talk_time += (rtp_session->vad_data.stop_talking - rtp_session->vad_data.start_talking);

                                                                        switch_clear_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING);
                                                                        
                                                                        rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
                                                                        if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)) {
                                                                                
                                                                                if ((rtp_session->vad_data.fire_events & VAD_FIRE_NOT_TALK)) {
                                                                                        switch_event_t *event;
                                                                                        if (switch_event_create(&event, SWITCH_EVENT_NOTALK) == SWITCH_STATUS_SUCCESS) {
                                                                                                switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
                                                                                                switch_event_fire(&event);
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }

                                if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)) {
                                        send = 1;
                                }
                        }
                } else {
                        ret = -1;
                        goto end;
                }
        }

        if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
                this_ts = ntohl(send_msg->header.ts);

                if ((this_ts - rtp_session->last_write_ts) > 16000) {
                        rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
                }

                if (!switch_rtp_ready(rtp_session) || rtp_session->sending_dtmf ||
                        (!rtp_session->flags[SWITCH_RTP_FLAG_RESET] && this_ts > rtp_session->one_second && this_ts < rtp_session->last_write_ts)) {
                        send = 0;
                }
        }

        if (rtp_session->flags[SWITCH_RTP_FLAG_PAUSE]) {
                send = 0;
        }

        if (send) {
                send_msg->header.seq = htons(++rtp_session->seq);

                if (rtp_session->flags[SWITCH_RTP_FLAG_BYTESWAP] && send_msg->header.pt == rtp_session->payload) {
                        switch_swap_linear((int16_t *)send_msg->body, (int) datalen);
                }

#ifdef ENABLE_SRTP
                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
                        int sbytes = (int) bytes;
                        err_status_t stat;


                        if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET] || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {
                                
                                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
                                srtp_dealloc(rtp_session->send_ctx[rtp_session->srtp_idx_rtp]);
                                rtp_session->send_ctx[rtp_session->srtp_idx_rtp] = NULL;
                                if ((stat = srtp_create(&rtp_session->send_ctx[rtp_session->srtp_idx_rtp], 
                                                                                &rtp_session->send_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, 
                                                                          "Error! RE-Activating %s Secure RTP SEND\n", rtp_type(rtp_session));
                                        rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
                                        ret = -1;
                                        goto end;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, 
                                                                          "RE-Activating %s Secure RTP SEND\n", rtp_type(rtp_session));
                                }
                        }


                        stat = srtp_protect(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &send_msg->header, &sbytes);
                        
                        if (stat) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, 
                                                                  "Error: %s SRTP protection failed with code %d\n", rtp_type(rtp_session), stat);
                        }

                        bytes = sbytes;
                }
#endif
#ifdef ENABLE_ZRTP
                /* ZRTP Send */
                if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                        unsigned int sbytes = (int) bytes;
                        zrtp_status_t stat = zrtp_status_fail;
                        

                        stat = zrtp_process_rtp(rtp_session->zrtp_stream, (void *) send_msg, &sbytes);

                        switch (stat) {
                        case zrtp_status_ok:
                                break;
                        case zrtp_status_drop:
                                /* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Error: zRTP protection drop with code %d\n", stat); */
                                ret = (int) bytes;
                                goto end;
                                break;
                        case zrtp_status_fail:
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
                                break;
                        default:
                                break;
                        }

                        bytes = sbytes;
                }
#endif

                now = switch_micro_time_now();
#ifdef RTP_DEBUG_WRITE_DELTA
                {
                        int delta = (int) (now - rtp_session->send_time) / 1000;
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "WRITE %d delta %d\n", (int) bytes, delta);
                }
#endif
                rtp_session->send_time = now;

                if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
                        const char *tx_host;
                        const char *old_host;
                        const char *my_host;

                        char bufa[50], bufb[50], bufc[50];


                        tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
                        old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
                        my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session), SWITCH_LOG_CONSOLE,
                                                          "W %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
                                                          rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
                                                          (long) bytes,
                                                          my_host, switch_sockaddr_get_port(rtp_session->local_addr),
                                                          old_host, rtp_session->remote_port,
                                                          tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
                                                          send_msg->header.pt, ntohl(send_msg->header.ts), ntohs(send_msg->header.seq), send_msg->header.m);

                }
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_NACK]) {
                        if (!rtp_session->vbw) {
                                switch_jb_create(&rtp_session->vbw, SJB_VIDEO, 30, 30, rtp_session->pool);
                                if (rtp_session->vbw) {
                                        switch_jb_set_flag(rtp_session->vbw, SJB_QUEUE_ONLY);
                                        //switch_jb_debug_level(rtp_session->vbw, 10);
                                }
                        }
                        switch_jb_put_packet(rtp_session->vbw, (switch_rtp_packet_t *)send_msg, bytes);
                }

#ifdef RTP_WRITE_PLOSS
                {
                        int r = (rand() % 10000) + 1;
                        
                        if (r <= 200) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ALERT, 
                                                                  "Simulate dropping packet ......... ts: %u seq: %u\n", ntohl(send_msg->header.ts), ntohs(send_msg->header.seq));
                        } else {
                                if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) send_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
                                        rtp_session->seq--;
                                        ret = -1;
                                        goto end;
                                }
                        }
                }
#else
                //if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                //
                //      rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]++;
                //
                //      //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "SEND %u\n", ntohs(send_msg->header.seq));
                //}
                if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) send_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
                        rtp_session->seq--;
                        ret = -1;
                        goto end;
                }
#endif
                rtp_session->last_write_ts = this_ts;
                rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;

                if (rtp_session->queue_delay) {
                        rtp_session->delay_samples = rtp_session->queue_delay;
                        rtp_session->queue_delay = 0;
                }

                rtp_session->stats.outbound.raw_bytes += bytes;
                rtp_session->stats.outbound.packet_count++;
                
                if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                        rtp_session->stats.rtcp.sent_pkt_count++;
                }

                if (send_msg->header.pt == rtp_session->cng_pt) {
                        rtp_session->stats.outbound.cng_packet_count++;
                } else {
                        rtp_session->stats.outbound.media_packet_count++;
                        rtp_session->stats.outbound.media_bytes += bytes;
                }

                if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                        rtp_session->last_write_samplecount = rtp_session->timer.samplecount;
                }

                rtp_session->last_write_timestamp = switch_micro_time_now();
        }

        ret = (int) bytes;

 end:

        WRITE_DEC(rtp_session);

        return ret;
}

static int rtp_write_ready ( switch_rtp_t *  rtp_session, uint32_t  bytes, int  line  )

static

Definition at line 7161 of file switch_rtp.c.

References DS_READY, switch_rtp::dtls, switch_rtp::ice, switch_rtp_ice_t::ice_user, switch_rtp_ice_t::ready, switch_rtp_ice_t::rready, rtp_type, switch_dtls_s::state, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG3, and switch_log_printf().

Referenced by read_rtp_packet(), rtp_common_write(), switch_rtp_ack_bitrate(), switch_rtp_req_bitrate(), switch_rtp_video_loss(), switch_rtp_video_refresh(), switch_rtp_write_frame(), switch_rtp_write_manual(), and switch_rtp_write_raw().

{
        if (!rtp_session) return 0;
        
        if (rtp_session->ice.ice_user && !(rtp_session->ice.rready || rtp_session->ice.ready)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG3, "Skip sending %s packet %ld bytes (ice not ready @ line %d!)\n", 
                                                  rtp_type(rtp_session), (long)bytes, line);
                return 0;
        }

        if (rtp_session->dtls && rtp_session->dtls->state != DS_READY) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG3, "Skip sending %s packet %ld bytes (dtls not ready @ line %d!)\n", 
                                                  rtp_type(rtp_session), (long)bytes, line);
                return 0;
        }
        
        return 1;
}

static void set_dtmf_delay ( switch_rtp_t *  rtp_session, uint32_t  ms, uint32_t  max_ms  )

static

Definition at line 4763 of file switch_rtp.c.

References switch_rtp::flags, switch_rtp::last_write_ts, switch_rtp::max_next_write_samplecount, switch_rtp::next_write_samplecount, switch_rtp::queue_delay, switch_timer::samplecount, switch_rtp::samples_per_second, switch_rtp::session, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_RTP_FLAG_USE_TIMER, and switch_rtp::timer.

Referenced by do_2833().

{
        int upsamp, max_upsamp;
                

        if (!max_ms) max_ms = ms;

        upsamp = ms * (rtp_session->samples_per_second / 1000);
        max_upsamp = max_ms * (rtp_session->samples_per_second / 1000);

        rtp_session->queue_delay = upsamp;

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
                rtp_session->max_next_write_samplecount = rtp_session->timer.samplecount + max_upsamp;
                rtp_session->next_write_samplecount = rtp_session->timer.samplecount + upsamp;
                rtp_session->last_write_ts += upsamp;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Queue digit delay of %dms\n", ms);       
}

switch_status_t switch_rtp_add_crypto_key	(	switch_rtp_t *	rtp_session,
		switch_rtp_crypto_direction_t	direction,
		uint32_t	index,
		switch_rtp_crypto_key_type_t	type,
		unsigned char *	key,
		switch_size_t	keylen
	)

Definition at line 3468 of file switch_rtp.c.

References AEAD_AES_128_GCM_8, AEAD_AES_256_GCM_8, AES_CM_128_HMAC_SHA1_32, AES_CM_128_HMAC_SHA1_80, AES_CM_128_NULL_AUTH, AES_CM_256_HMAC_SHA1_80, switch_rtp_crypto_key::index, switch_rtp_crypto_key::key, memset(), switch_rtp_crypto_key::next, switch_b64_encode(), SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_alloc, switch_core_get_variable(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CALL_SECURE, switch_event_create, switch_event_fire, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_RTP_CRYPTO_MAX, SWITCH_RTP_CRYPTO_RECV, SWITCH_RTP_CRYPTO_RECV_RTCP, SWITCH_RTP_CRYPTO_SEND, SWITCH_RTP_CRYPTO_SEND_RTCP, SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_RECV_RESET, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SECURE_SEND_RESET, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_MAX_CRYPTO_LEN, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), and switch_rtp_crypto_key::type.

Referenced by dtls_state_setup(), switch_core_media_recover_session(), switch_core_session_apply_crypto(), and switch_core_session_check_incoming_crypto().

{
#ifndef ENABLE_SRTP
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "SRTP NOT SUPPORTED IN THIS BUILD!\n");
        return SWITCH_STATUS_FALSE;
#else
        switch_rtp_crypto_key_t *crypto_key;
        srtp_policy_t *policy;
        err_status_t stat;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        
        switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
        switch_event_t *fsevent = NULL;
        int idx = 0;
        const char *var;
        unsigned char b64_key[512] = "";

        if (direction >= SWITCH_RTP_CRYPTO_MAX || keylen > SWITCH_RTP_MAX_CRYPTO_LEN) {
                return SWITCH_STATUS_FALSE;
        }

        switch_b64_encode(key, keylen, b64_key, sizeof(b64_key));

        if (switch_true(switch_core_get_variable("rtp_retain_crypto_keys"))) {
                switch(direction) {
                        case SWITCH_RTP_CRYPTO_SEND:
                                switch_channel_set_variable(channel, "srtp_local_crypto_key", (const char *)b64_key);
                                break;
                        case SWITCH_RTP_CRYPTO_RECV:
                                switch_channel_set_variable(channel, "srtp_remote_crypto_key", (const char *)b64_key);
                                break;
                        case SWITCH_RTP_CRYPTO_SEND_RTCP:
                                switch_channel_set_variable(channel, "srtcp_local_crypto_key", (const char *)b64_key);
                                break;
                        case SWITCH_RTP_CRYPTO_RECV_RTCP:
                                switch_channel_set_variable(channel, "srtcp_remote_crypto_key", (const char *)b64_key);
                                break;
                        default:
                                break;
                }
        }

        crypto_key = switch_core_alloc(rtp_session->pool, sizeof(*crypto_key));

        if (direction == SWITCH_RTP_CRYPTO_RECV_RTCP) {
                direction = SWITCH_RTP_CRYPTO_RECV;
                rtp_session->srtp_idx_rtcp = idx = 1;
        } else if (direction == SWITCH_RTP_CRYPTO_SEND_RTCP) {
                direction = SWITCH_RTP_CRYPTO_SEND;
                rtp_session->srtp_idx_rtcp = idx = 1;
        }

        if (direction == SWITCH_RTP_CRYPTO_RECV) {
                policy = &rtp_session->recv_policy[idx];
        } else {
                policy = &rtp_session->send_policy[idx];
        }

        crypto_key->type = type;
        crypto_key->index = index;
        memcpy(crypto_key->key, key, keylen);
        crypto_key->next = rtp_session->crypto_keys[direction];
        rtp_session->crypto_keys[direction] = crypto_key;

        memset(policy, 0, sizeof(*policy));

        /* many devices can't handle gaps in SRTP streams */
        if (!((var = switch_channel_get_variable(channel, "srtp_allow_idle_gaps"))
                  && switch_true(var))
                && (!(var = switch_channel_get_variable(channel, "send_silence_when_idle"))
                        || !(atoi(var)))) {
                switch_channel_set_variable(channel, "send_silence_when_idle", "-1");
        }

        switch (crypto_key->type) {
        case AES_CM_128_HMAC_SHA1_80:
                crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtp);
                crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtcp);

                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_80");
                }
                break;
        case AES_CM_128_HMAC_SHA1_32:
                crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtp);
                crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtcp);


                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_32");
                }
                break;

        case AEAD_AES_256_GCM_8:
                crypto_policy_set_aes_gcm_256_8_auth(&policy->rtp);
                crypto_policy_set_aes_gcm_256_8_auth(&policy->rtcp);

                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_256_GCM_8");
                }
                break;

        case AEAD_AES_128_GCM_8:
                crypto_policy_set_aes_gcm_128_8_auth(&policy->rtp);
                crypto_policy_set_aes_gcm_128_8_auth(&policy->rtcp);

                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_128_GCM_8");
                }
                break;

        case AES_CM_256_HMAC_SHA1_80:
                crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtp);
                crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtcp);
                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_256_HMAC_SHA1_80");
                }
                break;
        case AES_CM_128_NULL_AUTH:
                crypto_policy_set_aes_cm_128_null_auth(&policy->rtp);
                crypto_policy_set_aes_cm_128_null_auth(&policy->rtcp);
                
                if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_NULL_AUTH");
                }
                break;
        default:
                break;
        }

        policy->key = (uint8_t *) crypto_key->key;
        policy->next = NULL;
        
        policy->window_size = 1024;
        policy->allow_repeat_tx = 1;

        //policy->rtp.sec_serv = sec_serv_conf_and_auth;
        //policy->rtcp.sec_serv = sec_serv_conf_and_auth;

        switch (direction) {
        case SWITCH_RTP_CRYPTO_RECV:
                policy->ssrc.type = ssrc_any_inbound;

                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && idx == 0 && rtp_session->recv_ctx[idx]) {
                        rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_RESET] = 1;
                } else {
                        if ((stat = srtp_create(&rtp_session->recv_ctx[idx], policy)) || !rtp_session->recv_ctx[idx]) {
                                status = SWITCH_STATUS_FALSE;
                        }

                        if (status == SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s RECV\n", 
                                                                  rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "Video" : "Audio", idx ? "RTCP" : "RTP");
                                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 1;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating srtp [%d]\n", stat);
                                return status;
                        }
                }
                break;
        case SWITCH_RTP_CRYPTO_SEND:
                policy->ssrc.type = ssrc_any_outbound;
                //policy->ssrc.type = ssrc_specific;
                //policy->ssrc.value = rtp_session->ssrc;

                if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] && idx == 0 && rtp_session->send_ctx[idx]) {
                        rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET] = 1;
                } else {
                        if ((stat = srtp_create(&rtp_session->send_ctx[idx], policy)) || !rtp_session->send_ctx[idx]) {
                                status = SWITCH_STATUS_FALSE;
                        }

                        if (status == SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s SEND\n",
                                                                  rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "Video" : "Audio", idx ? "RTCP" : "RTP");
                                rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 1;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating SRTP [%d]\n", stat);
                                return status;
                        }
                }

                break;
        default:
                abort();
                break;
        }

        if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE) == SWITCH_STATUS_SUCCESS) {
                if (rtp_session->dtls) {
                        switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:dtls:AES_CM_128_HMAC_SHA1_80");
                        switch_channel_set_variable(channel, "rtp_has_crypto", "srtp:dtls:AES_CM_128_HMAC_SHA1_80");
                } else {
                        switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:sdes:%s", switch_channel_get_variable(channel, "rtp_has_crypto"));
                }
                switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
                switch_event_fire(&fsevent);
        }


        return SWITCH_STATUS_SUCCESS;
#endif
}

static void switch_rtp_change_ice_dest ( switch_rtp_t *  rtp_session, switch_rtp_ice_t *  ice, const char *  host, switch_port_t  port  )

static

Definition at line 516 of file switch_rtp.c.

References switch_rtp_ice_t::addr, ice_s::cands, ice_s::chosen, icand_s::con_addr, icand_s::con_port, switch_rtp::flags, switch_rtp_ice_t::ice_params, switch_rtp_ice_t::missed_count, switch_rtp::pool, switch_rtp_ice_t::proto, switch_rtp::remote_addr, switch_rtp::rtcp_ice, switch_rtp::rtcp_remote_addr, switch_core_strdup, SWITCH_FALSE, SWITCH_RTP_FLAG_RTCP_MUX, and switch_rtp_set_remote_address().

Referenced by handle_ice().

{
        int is_rtcp = ice == &rtp_session->rtcp_ice;
        const char *err = "";

        ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr = switch_core_strdup(rtp_session->pool, host);
        ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port = port;
        ice->missed_count = 0;

        if (is_rtcp) {
                ice->addr = rtp_session->rtcp_remote_addr;
        } else {
                switch_rtp_set_remote_address(rtp_session, host, port, 0, SWITCH_FALSE, &err);

                if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
                        ice->addr = rtp_session->remote_addr;
                }
        }

}

switch_status_t switch_rtp_create	(	switch_rtp_t **	new_rtp_session,
		switch_payload_t	payload,
		uint32_t	samples_per_interval,
		uint32_t	ms_per_packet,
		switch_rtp_flag_t	flags[SWITCH_RTP_FLAG_INVALID],
		char *	timer_name,
		const char **	err,
		switch_memory_pool_t *	pool
	)

Definition at line 3740 of file switch_rtp.c.

References switch_rtp_numbers_t::burstrate, CF_SECURE, switch_rtp::cng_pt, switch_rtp::conf_samples_per_interval, switch_rtp::dtmf_data, switch_rtp_rfc2833_data::dtmf_inqueue, switch_rtp_rfc2833_data::dtmf_mutex, switch_rtp_rfc2833_data::dtmf_queue, switch_rtp::flag_mutex, switch_rtp::flags, switch_rtp::from_addr, rtp_msg_t::header, switch_rtp::ice_mutex, switch_rtp_stats_t::inbound, INVALID_PT, switch_rtp_numbers_t::jitter_add, switch_rtp_numbers_t::jitter_addsq, switch_rtp_numbers_t::jitter_n, switch_rtp_numbers_t::last_loss, switch_rtp_numbers_t::last_proc_time, switch_rtp_numbers_t::last_processed_seq, switch_rtp_numbers_t::loss, switch_rtp_numbers_t::lossrate, switch_rtp_numbers_t::max_variance, memset(), switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, switch_rtp::payload, pool, switch_rtp::pool, switch_rtp_numbers_t::R, switch_rtp::read_mutex, switch_rtp::ready, switch_rtp::recv_msg, switch_rtp::recv_te, switch_rtp::rtcp_from_addr, switch_rtp::rtcp_last_sent, switch_rtp::rtp_from_addr, switch_rtp::send_msg, switch_rtp::seq, switch_rtp::session, switch_rtp::ssrc, switch_rtp::stats, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_private(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_channel_set_variable, switch_channel_test_flag(), switch_core_alloc, switch_core_memory_pool_get_data(), switch_core_session_get_channel(), switch_core_strdup, switch_core_timer_init(), switch_epoch_time_now(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_micro_time_now(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), switch_rtp_clear_flag(), SWITCH_RTP_FLAG_ENABLE_RTCP, SWITCH_RTP_FLAG_NOBLOCK, SWITCH_RTP_FLAG_PROXY_MEDIA, SWITCH_RTP_FLAG_USE_TIMER, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_MAX_BUF_LEN, switch_rtp_set_flag(), switch_rtp_set_flags(), switch_rtp_set_interval(), switch_sockaddr_create(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, switch_time_now(), switch_true(), switch_rtp::te, switch_rtp::timer, switch_rtp::timer_name, switch_rtp::write_mutex, and zstr.

Referenced by switch_rtp_new().

{
        switch_rtp_t *rtp_session = NULL;
        switch_core_session_t *session = switch_core_memory_pool_get_data(pool, "__session");
        switch_channel_t *channel = NULL;

        if (session) channel = switch_core_session_get_channel(session);

        *new_rtp_session = NULL;

        if (samples_per_interval > SWITCH_RTP_MAX_BUF_LEN) {
                *err = "Packet Size Too Large!";
                return SWITCH_STATUS_FALSE;
        }

        if (!(rtp_session = switch_core_alloc(pool, sizeof(*rtp_session)))) {
                *err = "Memory Error!";
                return SWITCH_STATUS_MEMERR;
        }

        rtp_session->pool = pool;
        rtp_session->te = INVALID_PT;
        rtp_session->recv_te = INVALID_PT;
        rtp_session->cng_pt = INVALID_PT;
        rtp_session->session = session;
        
        switch_mutex_init(&rtp_session->flag_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->read_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->write_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->ice_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&rtp_session->dtmf_data.dtmf_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_queue_create(&rtp_session->dtmf_data.dtmf_queue, 100, rtp_session->pool);
        switch_queue_create(&rtp_session->dtmf_data.dtmf_inqueue, 100, rtp_session->pool);

        switch_rtp_set_flags(rtp_session, flags);

        /* for from address on recvfrom calls */
        switch_sockaddr_create(&rtp_session->from_addr, pool);
        switch_sockaddr_create(&rtp_session->rtp_from_addr, pool);

        if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
                switch_sockaddr_create(&rtp_session->rtcp_from_addr, pool);
        }
        rtp_session->seq = (uint16_t) rand();
        rtp_session->ssrc = (uint32_t) ((intptr_t) rtp_session + (uint32_t) switch_epoch_time_now(NULL));

        rtp_session->stats.inbound.R = 100.0;
        rtp_session->stats.inbound.mos = 4.5;
        rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc);
        rtp_session->send_msg.header.ts = 0;
        rtp_session->send_msg.header.m = 0;
        rtp_session->send_msg.header.pt = (switch_payload_t) htonl(payload);
        rtp_session->send_msg.header.version = 2;
        rtp_session->send_msg.header.p = 0;
        rtp_session->send_msg.header.x = 0;
        rtp_session->send_msg.header.cc = 0;

        rtp_session->recv_msg.header.ssrc = 0;
        rtp_session->recv_msg.header.ts = 0;
        rtp_session->recv_msg.header.seq = 0;
        rtp_session->recv_msg.header.m = 0;
        rtp_session->recv_msg.header.pt = (switch_payload_t) htonl(payload);
        rtp_session->recv_msg.header.version = 2;
        rtp_session->recv_msg.header.p = 0;
        rtp_session->recv_msg.header.x = 0;
        rtp_session->recv_msg.header.cc = 0;

        rtp_session->payload = payload;
        rtp_session->rtcp_last_sent = switch_micro_time_now();

        switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);
        rtp_session->conf_samples_per_interval = samples_per_interval;

        if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && zstr(timer_name)) {
                timer_name = "soft";
        }

        if (!zstr(timer_name) && !strcasecmp(timer_name, "none")) {
                timer_name = NULL;
        }

        if (!zstr(timer_name)) {
                rtp_session->timer_name = switch_core_strdup(pool, timer_name);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);

                if (switch_core_timer_init(&rtp_session->timer, timer_name, ms_per_packet / 1000, samples_per_interval, pool) == SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG,
                                                          "Starting timer [%s] %d bytes per %dms\n", timer_name, samples_per_interval, ms_per_packet / 1000);
                } else {
                        memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR,
                                                          "Error Starting timer [%s] %d bytes per %dms, async RTP disabled\n", timer_name, samples_per_interval, ms_per_packet / 1000);
                        switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                }
        } else {
                if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                        if (switch_core_timer_init(&rtp_session->timer, "soft", 1, 90, pool) == SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Starting video timer.\n");
                        }

                        //switch_jb_create(&rtp_session->vb, 3, 10, rtp_session->pool);
                        //switch_jb_debug_level(rtp_session->vb, 10);

                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Not using a timer\n");
                }

                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
        }


        if (channel) {
                switch_channel_set_private(channel, "__rtcp_audio_rtp_session", rtp_session);
        }

#ifdef ENABLE_ZRTP
        if (zrtp_on && session && channel && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
                switch_rtp_t *master_rtp_session = NULL;

                int initiator = 0;
                const char *zrtp_enabled = switch_channel_get_variable(channel, "zrtp_secure_media");
                int srtp_enabled = switch_channel_test_flag(channel, CF_SECURE);

                if (srtp_enabled && switch_true(zrtp_enabled)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING,
                                                          "You can not have ZRTP and SRTP enabled simultaneously, ZRTP will be disabled for this call!\n");
                        switch_channel_set_variable(channel, "zrtp_secure_media", NULL);
                        zrtp_enabled = NULL;
                }


                if (switch_true(zrtp_enabled)) {
                        if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                                switch_channel_set_private(channel, "__zrtp_video_rtp_session", rtp_session);
                                master_rtp_session = switch_channel_get_private(channel, "__zrtp_audio_rtp_session");
                        } else {
                                switch_channel_set_private(channel, "__zrtp_audio_rtp_session", rtp_session);
                                master_rtp_session = rtp_session;
                        }


                        if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                                initiator = 1;
                        }

                        if (rtp_session == master_rtp_session) {
                                rtp_session->zrtp_profile = switch_core_alloc(rtp_session->pool, sizeof(*rtp_session->zrtp_profile));
                                zrtp_profile_defaults(rtp_session->zrtp_profile, zrtp_global);

                                rtp_session->zrtp_profile->allowclear = 0;
                                rtp_session->zrtp_profile->disclose_bit = 0;
                                rtp_session->zrtp_profile->cache_ttl = (uint32_t) -1;

                                if (zrtp_status_ok != zrtp_session_init(zrtp_global, rtp_session->zrtp_profile, zid, initiator, &rtp_session->zrtp_session)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error! zRTP INIT Failed\n");
                                        zrtp_session_down(rtp_session->zrtp_session);
                                        rtp_session->zrtp_session = NULL;
                                        goto end;
                                }

                                zrtp_session_set_userdata(rtp_session->zrtp_session, session);


                                if (zrtp_status_ok != zrtp_stream_attach(master_rtp_session->zrtp_session, &rtp_session->zrtp_stream)) {
                                        abort();
                                }

                                zrtp_stream_set_userdata(rtp_session->zrtp_stream, rtp_session);

                                if (switch_true(switch_channel_get_variable(channel, "zrtp_enrollment"))) {
                                        zrtp_stream_registration_start(rtp_session->zrtp_stream, rtp_session->ssrc);
                                } else {
                                        zrtp_stream_start(rtp_session->zrtp_stream, rtp_session->ssrc);
                                }
                        }

                }
        }

 end:

#endif

        /* Jitter */
        rtp_session->stats.inbound.last_proc_time = switch_time_now() / 1000;
        rtp_session->stats.inbound.jitter_n = 0;
        rtp_session->stats.inbound.jitter_add = 0;
        rtp_session->stats.inbound.jitter_addsq = 0;
        rtp_session->stats.inbound.min_variance = 0;
        rtp_session->stats.inbound.max_variance = 0;
        
        /* Burst and Packet Loss */
        rtp_session->stats.inbound.lossrate = 0;
        rtp_session->stats.inbound.burstrate = 0;
        memset(rtp_session->stats.inbound.loss, 0, sizeof(rtp_session->stats.inbound.loss));
        rtp_session->stats.inbound.last_loss = 0;
        rtp_session->stats.inbound.last_processed_seq = -1;

        rtp_session->ready = 1;
        *new_rtp_session = rtp_session;

        return SWITCH_STATUS_SUCCESS;
}

switch_rtp_t* switch_rtp_new	(	const char *	rx_host,
		switch_port_t	rx_port,
		const char *	tx_host,
		switch_port_t	tx_port,
		switch_payload_t	payload,
		uint32_t	samples_per_interval,
		uint32_t	ms_per_packet,
		switch_rtp_flag_t	flags[SWITCH_RTP_FLAG_INVALID],
		char *	timer_name,
		const char **	err,
		switch_memory_pool_t *	pool
	)

Definition at line 3950 of file switch_rtp.c.

References switch_rtp::flag_mutex, switch_rtp::pool, switch_rtp::ready, switch_rtp::rx_host, switch_rtp::rx_port, switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), switch_rtp_create(), SWITCH_RTP_FLAG_FLUSH, switch_rtp_release_port(), switch_rtp_set_flag(), switch_rtp_set_local_address(), switch_rtp_set_remote_address(), SWITCH_STATUS_SUCCESS, SWITCH_TRUE, and zstr.

{
        switch_rtp_t *rtp_session = NULL;

        if (zstr(rx_host)) {
                *err = "Missing local host";
                goto end;
        }

        if (!rx_port) {
                *err = "Missing local port";
                goto end;
        }

        if (zstr(tx_host)) {
                *err = "Missing remote host";
                goto end;
        }

        if (!tx_port) {
                *err = "Missing remote port";
                goto end;
        }

        if (switch_rtp_create(&rtp_session, payload, samples_per_interval, ms_per_packet, flags, timer_name, err, pool) != SWITCH_STATUS_SUCCESS) {
                goto end;
        }

        switch_mutex_lock(rtp_session->flag_mutex);

        if (switch_rtp_set_local_address(rtp_session, rx_host, rx_port, err) != SWITCH_STATUS_SUCCESS) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session = NULL;
                goto end;
        }

        if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, 0, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session = NULL;
                goto end;
        }

 end:

        if (rtp_session) {
                switch_mutex_unlock(rtp_session->flag_mutex);
                rtp_session->ready = 2;
                rtp_session->rx_host = switch_core_strdup(rtp_session->pool, rx_host);
                rtp_session->rx_port = rx_port;
                switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
        } else {
                switch_rtp_release_port(rx_host, rx_port);
        }

        return rtp_session;
}

void switch_rtp_reset_vb

(

switch_rtp_t *

rtp_session

)

Definition at line 2778 of file switch_rtp.c.

References switch_jb_reset().

Referenced by switch_rtp_reset().

{
        if (rtp_session->vb) {
                switch_jb_reset(rtp_session->vb);
        }

        if (rtp_session->vbw) {
                switch_jb_reset(rtp_session->vbw);
        }
}

static int using_ice ( switch_rtp_t *  rtp_session )

static

Definition at line 1946 of file switch_rtp.c.

References switch_rtp::ice, switch_rtp_ice_t::ice_user, and switch_rtp::rtcp_ice.

Referenced by check_rtcp_and_ice(), and rtp_common_read().

{
        if (rtp_session->ice.ice_user || rtp_session->rtcp_ice.ice_user) {
                return 1;
        }

        return 0;
}

Variable Documentation

switch_hash_t* alloc_hash = NULL

static

Definition at line 109 of file switch_rtp.c.

const char* dtls_state_names_t[] = {"OFF", "HANDSHAKE", "SETUP", "READY", "FAIL", "INVALID"}

static

Definition at line 2988 of file switch_rtp.c.

dtls_state_handler_t dtls_states[DS_INVALID] = {NULL, dtls_state_handshake, dtls_state_setup, dtls_state_ready, dtls_state_fail}

Definition at line 291 of file switch_rtp.c.

switch_port_t END_PORT = RTP_END_PORT

static

Definition at line 82 of file switch_rtp.c.

Referenced by switch_rtp_request_port(), and switch_rtp_set_end_port().

int global_init = 0

static

Definition at line 766 of file switch_rtp.c.

const switch_payload_t INVALID_PT = 255

static

Definition at line 75 of file switch_rtp.c.

Referenced by check_rtcp_and_ice(), rtp_common_read(), rtp_common_write(), switch_rtp_create(), switch_rtp_write_frame(), and switch_rtp_write_manual().

switch_mutex_t* port_lock = NULL

static

Definition at line 83 of file switch_rtp.c.

Referenced by switch_rtp_init(), switch_rtp_release_port(), switch_rtp_request_port(), switch_rtp_set_end_port(), switch_rtp_set_start_port(), and switch_rtp_shutdown().

switch_port_t START_PORT = RTP_START_PORT

static

Definition at line 81 of file switch_rtp.c.

Referenced by switch_rtp_request_port(), and switch_rtp_set_start_port().