#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:

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.

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.

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.

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.

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.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation