This graph shows which files directly or indirectly include this file:

Data Structures
struct	switch_rtp_packet_t

struct	switch_srtp_crypto_suite_s

struct	switch_rtp_crypto_key

struct	icand_s

struct	ice_s

Macros
#define	SWITCH_RTP_HEADER_LEN sizeof(switch_rtp_hdr_t)

#define	SWITCH_RTP_MAX_BUF_LEN 16384

#define	SWITCH_RTCP_MAX_BUF_LEN 16384

#define	SWITCH_RTP_MAX_BUF_LEN_WORDS 4094 /* (max / 4) - 2 */

#define	SWITCH_RTP_MAX_PACKET_LEN (SWITCH_RTP_MAX_BUF_LEN + SWITCH_RTP_HEADER_LEN)

#define	SWITCH_RTP_CRYPTO_KEY_80 "AES_CM_128_HMAC_SHA1_80"

#define	SWITCH_RTP_BUNDLE_INTERNAL_PT 21

#define	MAX_CAND 50

#define	MAX_CAND_IDX_COUNT 2

Typedefs
typedef struct switch_srtp_crypto_suite_s	switch_srtp_crypto_suite_t

typedef struct switch_rtp_crypto_key	switch_rtp_crypto_key_t

typedef struct icand_s	icand_t

typedef struct ice_s	ice_t

typedef void(*	switch_rtp_invalid_handler_t) (switch_rtp_t rtp_session, switch_socket_t sock, void data, switch_size_t datalen, switch_sockaddr_t from_addr)

Enumerations
enum	switch_rtp_crypto_direction_t { SWITCH_RTP_CRYPTO_SEND, SWITCH_RTP_CRYPTO_RECV, SWITCH_RTP_CRYPTO_SEND_RTCP, SWITCH_RTP_CRYPTO_RECV_RTCP, SWITCH_RTP_CRYPTO_MAX }

enum	ice_proto_t { IPR_RTP, IPR_RTCP }

enum	rtcp_pt_t { _RTCP_PT_FIR = 192, _RTCP_PT_IJ = 195, _RTCP_PT_SR = 200, _RTCP_PT_RR = 201, _RTCP_PT_SDES = 202, _RTCP_PT_BYE = 203, _RTCP_PT_APP = 204, _RTCP_PT_RTPFB = 205, _RTCP_PT_PSFB = 206, _RTCP_PT_XR = 207, _RTCP_PT_AVB = 208, _RTCP_PT_RSI = 209, _RTCP_PT_TOKEN = 210, _RTCP_PT_IDMS = 211, _RTCP_PT_LAST = 255 }

enum	rtcp_sdes_t { _RTCP_SDES_END = 0, _RTCP_SDES_CNAME = 1, _RTCP_SDES_NAME = 2, _RTCP_SDES_EMAIL = 3, _RTCP_SDES_PHONE = 4, _RTCP_SDES_LOC = 5, _RTCP_SDES_TOOL = 6, _RTCP_SDES_NOTE = 7, _RTCP_SDES_PRIV = 8, _RTCP_SDES_H323 = 9, _RTCP_SDES_APSI = 10 }

enum	rtcp_rtpfb_t { _RTCP_RTPFB_NACK = 1, _RTCP_RTPFB_TMMBR = 3, _RTCP_RTPFB_TMMBN = 4, _RTCP_RTPFB_SR_REQ = 5, _RTCP_RTPFB_RAMS = 6, _RTCP_RTPFB_TLLEI = 7, _RTCP_RTPFB_ECN_FB = 8 }

enum	rtcp_psfb_t { _RTCP_PSFB_PLI = 1, _RTCP_PSFB_SLI = 2, _RTCP_PSFB_RPSI = 3, _RTCP_PSFB_FIR = 4, _RTCP_PSFB_TSTR = 5, _RTCP_PSFB_TSTN = 6, _RTCP_PSFB_VBCM = 7, _RTCP_PSFB_PSLEI = 8, _RTCP_PSFB_AFB = 15 }

Functions
switch_status_t	switch_rtp_add_crypto_key (switch_rtp_t rtp_session, switch_rtp_crypto_direction_t direction, uint32_t index, switch_secure_settings_t ssec)

void	switch_rtp_get_random (void *buf, uint32_t len)

void	switch_rtp_init (switch_memory_pool_t *pool)
	Initilize the RTP System. More...

void	switch_rtp_shutdown (void)

switch_port_t	switch_rtp_set_start_port (switch_port_t port)
	Set/Get RTP start port. More...

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_port_t	switch_rtp_set_end_port (switch_port_t port)
	Set/Get RTP end port. More...

switch_port_t	switch_rtp_request_port (const char *ip)
	Request a new port to be used for media. More...

void	switch_rtp_release_port (const char *ip, switch_port_t port)

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_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)
	create a new RTP session handle More...

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, switch_port_t bundle_internal_ports, switch_port_t bundle_external_port)
	prepare a new RTP session handle and fully initilize it More...

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...

void	switch_rtp_reset_jb (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)

void	switch_rtp_reset_media_timer (switch_rtp_t *rtp_session)

void	switch_rtp_set_max_missed_packets (switch_rtp_t *rtp_session, uint32_t max)

void	switch_rtp_set_media_timeout (switch_rtp_t *rtp_session, uint32_t ms)

switch_status_t	switch_rtp_udptl_mode (switch_rtp_t *rtp_session)

void	switch_rtp_reset (switch_rtp_t *rtp_session)

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_kill_socket (switch_rtp_t *rtp_session)
	Kill the socket on an existing RTP session. More...

void	switch_rtp_break (switch_rtp_t *rtp_session)

void	switch_rtp_flush (switch_rtp_t *rtp_session)

uint8_t	switch_rtp_ready (switch_rtp_t *rtp_session)
	Test if an RTP session is ready. More...

void	switch_rtp_destroy (switch_rtp_t **rtp_session)
	Destroy an RTP session. More...

switch_status_t	switch_rtp_sync_stats (switch_rtp_t *rtp_session)

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...

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_timer_t *	switch_rtp_get_media_timer (switch_rtp_t *rtp_session)

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_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_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_debug_jitter_buffer (switch_rtp_t rtp_session, const char name)

switch_status_t	switch_rtp_deactivate_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_jb_t *	switch_rtp_get_jitter_buffer (switch_rtp_t *rtp_session)

void	switch_rtp_set_flag (switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
	Set an RTP Flag. 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])

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...

switch_socket_t *	switch_rtp_get_rtp_socket (switch_rtp_t *rtp_session)
	Retrieve the socket from an existing RTP session. More...

void	switch_rtp_ping (switch_rtp_t *rtp_session)

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...

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_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_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_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_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_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...

void	rtp_flush_read_buffer (switch_rtp_t *rtp_session, switch_rtp_flush_t flush)

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...

switch_status_t	switch_rtp_disable_vad (switch_rtp_t *rtp_session)
	Disable 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...

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_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...

void *	switch_rtp_get_private (switch_rtp_t *rtp_session)
	Retrieve the private data from a given RTP session. 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)

switch_rtp_stats_t *	switch_rtp_get_stats (switch_rtp_t rtp_session, switch_memory_pool_t pool)

switch_byte_t	switch_rtp_check_auto_adj (switch_rtp_t *rtp_session)

void	switch_rtp_set_interdigit_delay (switch_rtp_t *rtp_session, uint32_t delay)

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, uint8_t want_DTLSv1_2)

switch_status_t	switch_rtp_del_dtls (switch_rtp_t *rtp_session, dtls_type_t type)

dtls_state_t	switch_rtp_dtls_state (switch_rtp_t *rtp_session, dtls_type_t type)

int	switch_rtp_has_dtls (void)

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)

switch_core_session_t *	switch_rtp_get_core_session (switch_rtp_t *rtp_session)

Detailed Description

RTP.

Definition in file switch_rtp.h.

Macro Definition Documentation

◆ MAX_CAND

#define MAX_CAND 50

Definition at line 110 of file switch_rtp.h.

Referenced by check_ice().

◆ MAX_CAND_IDX_COUNT

#define MAX_CAND_IDX_COUNT 2

Definition at line 111 of file switch_rtp.h.

Referenced by check_ice().

◆ SWITCH_RTCP_MAX_BUF_LEN

#define SWITCH_RTCP_MAX_BUF_LEN 16384

Definition at line 46 of file switch_rtp.h.

◆ SWITCH_RTP_BUNDLE_INTERNAL_PT

#define SWITCH_RTP_BUNDLE_INTERNAL_PT 21

Definition at line 53 of file switch_rtp.h.

◆ SWITCH_RTP_CRYPTO_KEY_80

#define SWITCH_RTP_CRYPTO_KEY_80 "AES_CM_128_HMAC_SHA1_80"

Definition at line 51 of file switch_rtp.h.

◆ SWITCH_RTP_HEADER_LEN

#define SWITCH_RTP_HEADER_LEN sizeof(switch_rtp_hdr_t)

Definition at line 44 of file switch_rtp.h.

Referenced by switch_jb_peek_frame().

◆ SWITCH_RTP_MAX_BUF_LEN

#define SWITCH_RTP_MAX_BUF_LEN 16384

Definition at line 45 of file switch_rtp.h.

Referenced by find_free_frame(), switch_core_media_read_frame(), switch_core_session_write_blank_video(), switch_frame_dup(), switch_media_handle_create(), switch_rtp_create(), switch_rtp_text_factory_create(), switch_rtp_write_manual(), switch_rtp_write_raw(), video_bug_thread(), video_helper_thread(), and video_write_thread().

◆ SWITCH_RTP_MAX_BUF_LEN_WORDS

#define SWITCH_RTP_MAX_BUF_LEN_WORDS 4094 /* (max / 4) - 2 */

Definition at line 47 of file switch_rtp.h.

Referenced by read_rtp_packet().

◆ SWITCH_RTP_MAX_PACKET_LEN

#define SWITCH_RTP_MAX_PACKET_LEN (SWITCH_RTP_MAX_BUF_LEN + SWITCH_RTP_HEADER_LEN)

Definition at line 48 of file switch_rtp.h.

Referenced by switch_jb_put_packet().

Typedef Documentation

◆ icand_t

typedef struct icand_s icand_t

◆ ice_t

typedef struct ice_s ice_t

◆ switch_rtp_crypto_key_t

typedef struct switch_rtp_crypto_key switch_rtp_crypto_key_t

Definition at line 85 of file switch_rtp.h.

◆ switch_srtp_crypto_suite_t

typedef struct switch_srtp_crypto_suite_s switch_srtp_crypto_suite_t

Enumeration Type Documentation

◆ ice_proto_t

enum ice_proto_t

Enumerator
IPR_RTP
IPR_RTCP

Definition at line 87 of file switch_rtp.h.

              {
         IPR_RTP,
         IPR_RTCP
 } ice_proto_t;

◆ rtcp_psfb_t

enum rtcp_psfb_t

Enumerator
_RTCP_PSFB_PLI
_RTCP_PSFB_SLI
_RTCP_PSFB_RPSI
_RTCP_PSFB_FIR
_RTCP_PSFB_TSTR
_RTCP_PSFB_TSTN
_RTCP_PSFB_VBCM
_RTCP_PSFB_PSLEI
_RTCP_PSFB_AFB

Definition at line 166 of file switch_rtp.h.

              { /* FMT Values for PSFB Payload Types http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-9 */
         _RTCP_PSFB_PLI   = 1, /* PLI: Picture Loss Indication RFC4585 */
         _RTCP_PSFB_SLI   = 2, /* SLI: Slice Loss Indication RFC4585 */
         _RTCP_PSFB_RPSI  = 3, /* RPSI: Reference Picture Selection Indication RFC4585 */
         _RTCP_PSFB_FIR   = 4, /* FIR: Full Intra Request Command RFC5104 */
         _RTCP_PSFB_TSTR  = 5, /* TSTR: Temporal-Spatial Trade-off Request RFC5104 */
         _RTCP_PSFB_TSTN  = 6, /* TSTN: Temporal-Spatial Trade-off Notification RFC5104 */
         _RTCP_PSFB_VBCM  = 7, /* VBCM: Video Back Channel Message RFC5104 */
         _RTCP_PSFB_PSLEI = 8, /* PSLEI: Payload-Specific Third-Party Loss Early Indication RFC6642*/
         _RTCP_PSFB_AFB   = 15 /* AFB Application layer FB */
 } rtcp_psfb_t;

◆ rtcp_pt_t

enum rtcp_pt_t

Enumerator
_RTCP_PT_FIR
_RTCP_PT_IJ
_RTCP_PT_SR
_RTCP_PT_RR
_RTCP_PT_SDES
_RTCP_PT_BYE
_RTCP_PT_APP
_RTCP_PT_RTPFB
_RTCP_PT_PSFB
_RTCP_PT_XR
_RTCP_PT_AVB
_RTCP_PT_RSI
_RTCP_PT_TOKEN
_RTCP_PT_IDMS
_RTCP_PT_LAST

Definition at line 124 of file switch_rtp.h.

              { /* RTCP Control Packet types (PT) http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-4 */
         _RTCP_PT_FIR   = 192, /* [RFC 2032] RTP Payload Format for H.261 Video Streams. types 192 (FIR) section 5.2.1 */
         _RTCP_PT_IJ    = 195, /* IJ: Extended inter-arrival jitter report RFC5450*/
         _RTCP_PT_SR    = 200, /* SR: sender report RFC3550 */
         _RTCP_PT_RR    = 201, /* RR: receiver report RFC3550 */
         _RTCP_PT_SDES  = 202, /* SDES: source description RFC3550 */
         _RTCP_PT_BYE   = 203, /* BYE: goodbye RFC3550 */
         _RTCP_PT_APP   = 204, /* APP: application-defined RFC3550 */
         _RTCP_PT_RTPFB = 205, /* RTPFB: RTCP Transport layer FB message RFC4585 */
         _RTCP_PT_PSFB  = 206, /* PSFB: RTCP Payload-specific FB message RFC4585 */
         _RTCP_PT_XR    = 207, /* XR: extended report RFC3611 */
         _RTCP_PT_AVB   = 208, /* AVB: "Standard for Layer 3 Transport Protocol for Time Sensitive Applications in Local Area Networks." Work in progress. */
         _RTCP_PT_RSI   = 209, /* RSI: Receiver Summary Information RFC5760 */
         _RTCP_PT_TOKEN = 210, /* TOKEN: Port Mapping RFC6284 */
         _RTCP_PT_IDMS  = 211, /* IDMS: IDMS Settings RFC7272 */
         _RTCP_PT_LAST  = 255  /* RESERVED */
 } rtcp_pt_t;

◆ rtcp_rtpfb_t

enum rtcp_rtpfb_t

Enumerator
_RTCP_RTPFB_NACK
_RTCP_RTPFB_TMMBR
_RTCP_RTPFB_TMMBN
_RTCP_RTPFB_SR_REQ
_RTCP_RTPFB_RAMS
_RTCP_RTPFB_TLLEI
_RTCP_RTPFB_ECN_FB

Definition at line 156 of file switch_rtp.h.

              { /* FMT Values for RTPFB Payload Types http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-8 */
         _RTCP_RTPFB_NACK   = 1, /* Generic NACK: Generic negative acknowledgement RFC4585 */
         _RTCP_RTPFB_TMMBR  = 3, /* TMMBR: Temporary Maximum Media Stream Bit Rate Request RFC5104 */
         _RTCP_RTPFB_TMMBN  = 4, /* TMMBN: Temporary Maximum Media Stream Bit Rate Notification RFC5104 */
         _RTCP_RTPFB_SR_REQ = 5, /* RTCP-SR-REQ: TCP Rapid Resynchronisation Request RFC6051*/
         _RTCP_RTPFB_RAMS   = 6, /* RAMS: Rapid Acquisition of Multicast Sessions RFC6285 */
         _RTCP_RTPFB_TLLEI  = 7, /* TLLEI: Transport-Layer Third-Party Loss Early Indication RFC6642 */
         _RTCP_RTPFB_ECN_FB = 8  /* RTCP-ECN-FB: RTCP ECN Feedback RFC6679*/
 } rtcp_rtpfb_t;

◆ rtcp_sdes_t

enum rtcp_sdes_t

Enumerator
_RTCP_SDES_END
_RTCP_SDES_CNAME
_RTCP_SDES_NAME
_RTCP_SDES_EMAIL
_RTCP_SDES_PHONE
_RTCP_SDES_LOC
_RTCP_SDES_TOOL
_RTCP_SDES_NOTE
_RTCP_SDES_PRIV
_RTCP_SDES_H323
_RTCP_SDES_APSI

Definition at line 142 of file switch_rtp.h.

              { /* RTP SDES item types http://www.iana.org/assignments/rtp-parameters/rtp-parameters.xhtml#rtp-parameters-5 */
         _RTCP_SDES_END   = 0, /* END: end of sdes list RFC3550 */
         _RTCP_SDES_CNAME = 1, /* CNAME: canonical name RFC3550 */
         _RTCP_SDES_NAME  = 2, /* NAME: user name RFC3550 */
         _RTCP_SDES_EMAIL = 3, /* EMAIL: user's electronic mail address RFC3550 */
         _RTCP_SDES_PHONE = 4, /* PHONE: user's phone number RFC3550 */
         _RTCP_SDES_LOC   = 5, /* LOC: geographic user location RFC3550 */
         _RTCP_SDES_TOOL  = 6, /* TOOL: name of application or tool RFC3550 */
         _RTCP_SDES_NOTE  = 7, /* NOTE: notice about the source RFC3550 */
         _RTCP_SDES_PRIV  = 8, /* PRIV: private extensions RFC3550 */
         _RTCP_SDES_H323  = 9, /* H323-CADDR: H.323 callable address [Vineet Kumar] */
         _RTCP_SDES_APSI  = 10 /* APSI: Application specific identifer RFC6776 */
 } rtcp_sdes_t;

◆ switch_rtp_crypto_direction_t

enum switch_rtp_crypto_direction_t

Enumerator
SWITCH_RTP_CRYPTO_SEND
SWITCH_RTP_CRYPTO_RECV
SWITCH_RTP_CRYPTO_SEND_RTCP
SWITCH_RTP_CRYPTO_RECV_RTCP
SWITCH_RTP_CRYPTO_MAX

Definition at line 62 of file switch_rtp.h.

              {
         SWITCH_RTP_CRYPTO_SEND,
         SWITCH_RTP_CRYPTO_RECV,
         SWITCH_RTP_CRYPTO_SEND_RTCP,
         SWITCH_RTP_CRYPTO_RECV_RTCP,
         SWITCH_RTP_CRYPTO_MAX
 } switch_rtp_crypto_direction_t;

Function Documentation

◆ switch_rtp_add_crypto_key()

switch_status_t switch_rtp_add_crypto_key	(	switch_rtp_t *	rtp_session,
		switch_rtp_crypto_direction_t	direction,
		uint32_t	index,
		switch_secure_settings_t *	ssec
	)

Definition at line 4059 of file switch_rtp.c.

References AEAD_AES_128_GCM, AEAD_AES_128_GCM_8, AEAD_AES_256_GCM, AEAD_AES_256_GCM_8, AES_CM_128_HMAC_SHA1_32, AES_CM_128_HMAC_SHA1_80, AES_CM_128_NULL_AUTH, AES_CM_192_HMAC_SHA1_32, AES_CM_192_HMAC_SHA1_80, AES_CM_256_HMAC_SHA1_32, AES_CM_256_HMAC_SHA1_80, switch_rtp::crypto_keys, secure_settings_s::crypto_type, switch_rtp::dtls, switch_rtp::flags, switch_rtp_crypto_key::index, index, switch_rtp_crypto_key::keysalt, secure_settings_s::local_key_material_n, secure_settings_s::local_key_material_next, secure_settings_s::local_raw_key, memset(), switch_crypto_key_material_s::mki_id, switch_crypto_key_material_s::mki_size, switch_rtp_crypto_key::next, switch_crypto_key_material_s::next, switch_rtp::pool, switch_crypto_key_material_s::raw_key, switch_rtp::recv_ctx, switch_rtp::recv_policy, secure_settings_s::remote_key_material_n, secure_settings_s::remote_key_material_next, secure_settings_s::remote_raw_key, rtp_type, switch_rtp::send_ctx, switch_rtp::send_policy, switch_rtp::session, switch_rtp::srtp_idx_rtcp, switch_b64_encode(), SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_get_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_alloc, switch_core_get_variable(), switch_core_media_crypto_keysalt_len(), switch_core_session_get_channel(), switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CALL_SECURE, switch_event_create, switch_event_fire, SWITCH_LOG_CRIT, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_RTP_CRYPTO_MAX, SWITCH_RTP_CRYPTO_RECV, SWITCH_RTP_CRYPTO_RECV_RTCP, SWITCH_RTP_CRYPTO_SEND, SWITCH_RTP_CRYPTO_SEND_RTCP, SWITCH_RTP_FLAG_SECURE_RECV, SWITCH_RTP_FLAG_SECURE_RECV_MKI, SWITCH_RTP_FLAG_SECURE_RECV_RESET, SWITCH_RTP_FLAG_SECURE_SEND, SWITCH_RTP_FLAG_SECURE_SEND_MKI, SWITCH_RTP_FLAG_SECURE_SEND_RESET, SWITCH_RTP_FLAG_VIDEO, SWITCH_RTP_MAX_CRYPTO_LEN, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), and switch_rtp_crypto_key::type.

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

 {
 #ifndef ENABLE_SRTP
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "SRTP NOT SUPPORTED IN THIS BUILD!\n");
         return SWITCH_STATUS_FALSE;
 #else
 
         switch_rtp_crypto_key_t *crypto_key;
         srtp_policy_t *policy;
         srtp_err_status_t stat;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
         switch_event_t *fsevent = NULL;
         int idx = 0;
         const char *var;
         unsigned char b64_key[512] = "";
         
         unsigned char   *keysalt = NULL;
         switch_size_t   keysalt_len = 0;
         
         switch_crypto_key_material_t    *key_material = NULL;
         unsigned long                                   *key_material_n = NULL;
         srtp_master_key_t               **mkis = NULL;
         srtp_master_key_t               *mki = NULL;
         int mki_idx = 0;
 
         keysalt_len = switch_core_media_crypto_keysalt_len(ssec->crypto_type);
 
         if (direction >= SWITCH_RTP_CRYPTO_MAX || keysalt_len > SWITCH_RTP_MAX_CRYPTO_LEN) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (direction == SWITCH_RTP_CRYPTO_RECV_RTCP) {
                 direction = SWITCH_RTP_CRYPTO_RECV;
                 rtp_session->srtp_idx_rtcp = idx = 1;
         } else if (direction == SWITCH_RTP_CRYPTO_SEND_RTCP) {
                 direction = SWITCH_RTP_CRYPTO_SEND;
                 rtp_session->srtp_idx_rtcp = idx = 1;
         }
 
         if (direction == SWITCH_RTP_CRYPTO_RECV) {
                 policy = &rtp_session->recv_policy[idx];
                 keysalt = ssec->remote_raw_key;
                 key_material = ssec->remote_key_material_next;
                 key_material_n = &ssec->remote_key_material_n;
         } else {
                 policy = &rtp_session->send_policy[idx];
                 keysalt = ssec->local_raw_key;
                 key_material = ssec->local_key_material_next;
                 key_material_n = &ssec->local_key_material_n;
         }
 
         switch_b64_encode(keysalt, keysalt_len, b64_key, sizeof(b64_key));
 
         if (switch_true(switch_core_get_variable("rtp_retain_crypto_keys"))) {
                 switch(direction) {
                         case SWITCH_RTP_CRYPTO_SEND:
                                 switch_channel_set_variable(channel, "srtp_local_crypto_key", (const char *)b64_key);
                                 break;
                         case SWITCH_RTP_CRYPTO_RECV:
                                 switch_channel_set_variable(channel, "srtp_remote_crypto_key", (const char *)b64_key);
                                 break;
                         default:
                                 break;
                 }
 
                 if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
                         switch(direction) {
                         case SWITCH_RTP_CRYPTO_SEND:
                                 switch_channel_set_variable(channel, "srtp_local_video_crypto_key", (const char *)b64_key);
                                 break;
                         case SWITCH_RTP_CRYPTO_RECV:
                                 switch_channel_set_variable(channel, "srtp_remote_video_crypto_key", (const char *)b64_key);
                                 break;
                         default:
                                 break;
                         }
 
                 } else {
                         switch(direction) {
                         case SWITCH_RTP_CRYPTO_SEND:
                                 switch_channel_set_variable(channel, "srtp_local_audio_crypto_key", (const char *)b64_key);
                                 break;
                         case SWITCH_RTP_CRYPTO_RECV:
                                 switch_channel_set_variable(channel, "srtp_remote_audio_crypto_key", (const char *)b64_key);
                                 break;
                         default:
                                 break;
                         }
                 }
         }
 
         crypto_key = switch_core_alloc(rtp_session->pool, sizeof(*crypto_key));
 
         crypto_key->type = ssec->crypto_type;
         crypto_key->index = index;
         memcpy(crypto_key->keysalt, keysalt, keysalt_len);
         crypto_key->next = rtp_session->crypto_keys[direction];
         rtp_session->crypto_keys[direction] = crypto_key;
 
         memset(policy, 0, sizeof(*policy));
 
         /* many devices can't handle gaps in SRTP streams */
         if (!((var = switch_channel_get_variable(channel, "srtp_allow_idle_gaps"))
                   && switch_true(var))
                 && (!(var = switch_channel_get_variable(channel, "send_silence_when_idle"))
                         || !(atoi(var)))) {
                 switch_channel_set_variable(channel, "send_silence_when_idle", "-1");
         }
 
         switch (crypto_key->type) {
         case AES_CM_128_HMAC_SHA1_80:
                 srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_80");
                 }
                 break;
         case AES_CM_128_HMAC_SHA1_32:
                 srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtcp);
 
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_32");
                 }
                 break;
 
         case AEAD_AES_256_GCM_8:
                 srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy->rtp);
                 srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_256_GCM_8");
                 }
                 break;
 
         case AEAD_AES_256_GCM:
                 srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy->rtp);
                 srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_256_GCM");
                 }
                 break;
 
         case AEAD_AES_128_GCM_8:
                 srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy->rtp);
                 srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_128_GCM_8");
                 }
                 break;
 
         case AEAD_AES_128_GCM:
                 srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy->rtp);
                 srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_128_GCM");
                 }
                 break;
 
         case AES_CM_256_HMAC_SHA1_80:
                 srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtcp);
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_256_HMAC_SHA1_80");
                 }
                 break;
         case AES_CM_256_HMAC_SHA1_32:
                 srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(&policy->rtcp);
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_256_HMAC_SHA1_32");
                 }
                 break;
         case AES_CM_192_HMAC_SHA1_80:
                 srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_192_hmac_sha1_80(&policy->rtcp);
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_192_HMAC_SHA1_80");
                 }
                 break;
         case AES_CM_192_HMAC_SHA1_32:
                 srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_192_hmac_sha1_32(&policy->rtcp);
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_192_HMAC_SHA1_32");
                 }
                 break;
         case AES_CM_128_NULL_AUTH:
                 srtp_crypto_policy_set_aes_cm_128_null_auth(&policy->rtp);
                 srtp_crypto_policy_set_aes_cm_128_null_auth(&policy->rtcp);
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_NULL_AUTH");
                 }
                 break;
         default:
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Missing crypto type!\n");
                 break;
         }
 
         /* Setup the policy with MKI if they are used. Number of key materials must be positive to use MKI. */
         if (key_material && (*key_material_n > 0)) {
 
                 if (direction == SWITCH_RTP_CRYPTO_RECV) {
                         rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI] = 1;        /* tell the rest of the environment MKI is used */
                 } else {
                         rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI] = 1;        /* tell the rest of the environment MKI is used */
                 }
 
                 /* key must be NULL for libsrtp to work correctly with MKI. */
                 policy->key = NULL;
 
                 /* Allocate array for MKIs. */
                 mkis = switch_core_alloc(rtp_session->pool, *key_material_n * sizeof(srtp_master_key_t*));
                 if (!mkis) {
                         return SWITCH_STATUS_FALSE;
                 }
 
                 /* Build array of MKIs. */
                 mki_idx = 0;
 
                 while (key_material && (mki_idx < *key_material_n)) {
 
                         if (key_material->mki_size < 1) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "MKI bad key size at MKI %d\n", mki_idx);
                                 return SWITCH_STATUS_FALSE;
                         }
 
                         mki = switch_core_alloc(rtp_session->pool, sizeof(srtp_master_key_t));
                         if (!mki) {
                                 return SWITCH_STATUS_FALSE;
                         }
 
                         /* Setup MKI. */
                         mki->mki_id = switch_core_alloc(rtp_session->pool, sizeof(key_material->mki_size));
                         if (!mki->mki_id) {
                                 return SWITCH_STATUS_FALSE;
                         }
 
                         mki->key = switch_core_alloc(rtp_session->pool, keysalt_len);
                         if (!mki->key) {
                                 return SWITCH_STATUS_FALSE;
                         }
 
                         memcpy(mki->mki_id, &key_material->mki_id, key_material->mki_size);
                         mki->mki_size = key_material->mki_size;
                         memcpy(mki->key, key_material->raw_key, keysalt_len);
 
                         mkis[mki_idx] = mki;
 
                         key_material = key_material->next;
                         ++mki_idx;
                 }
 
                 /* And pass the array of MKIs to libsrtp. */
                 policy->keys = mkis;
                 policy->num_master_keys = mki_idx;
 
         } else {
                 policy->key = (uint8_t *) crypto_key->keysalt;
         }
 
         policy->next = NULL;
 
         policy->window_size = 1024;
         policy->allow_repeat_tx = 1;
 
         //policy->rtp.sec_serv = sec_serv_conf_and_auth;
         //policy->rtcp.sec_serv = sec_serv_conf_and_auth;
 
         switch (direction) {
         case SWITCH_RTP_CRYPTO_RECV:
                 policy->ssrc.type = ssrc_any_inbound;
 
                 if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && idx == 0 && rtp_session->recv_ctx[idx]) {
                         rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_RESET] = 1;
                 } else {
                         if ((stat = srtp_create(&rtp_session->recv_ctx[idx], policy)) || !rtp_session->recv_ctx[idx]) {
                                 status = SWITCH_STATUS_FALSE;
                         }
 
                         if (status == SWITCH_STATUS_SUCCESS) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s RECV%s\n",
                                                                   rtp_type(rtp_session), idx ? "RTCP" : "RTP", rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI] ? " (with MKI)" : "");
                                 rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 1;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating srtp [%d]\n", stat);
                                 return status;
                         }
                 }
                 break;
         case SWITCH_RTP_CRYPTO_SEND:
                 policy->ssrc.type = ssrc_any_outbound;
                 //policy->ssrc.type = ssrc_specific;
                 //policy->ssrc.value = rtp_session->ssrc;
 
                 if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] && idx == 0 && rtp_session->send_ctx[idx]) {
                         rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET] = 1;
                 } else {
                         if ((stat = srtp_create(&rtp_session->send_ctx[idx], policy)) || !rtp_session->send_ctx[idx]) {
                                 status = SWITCH_STATUS_FALSE;
                         }
 
                         if (status == SWITCH_STATUS_SUCCESS) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s SEND%s\n",
                                                                   rtp_type(rtp_session), idx ? "RTCP" : "RTP", rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI] ? " (with MKI)" : "");
                                 rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 1;
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating SRTP [%d]\n", stat);
                                 return status;
                         }
                 }
 
                 break;
         default:
                 abort();
                 break;
         }
 
         if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE) == SWITCH_STATUS_SUCCESS) {
                 if (rtp_session->dtls) {
                         switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:dtls:AES_CM_128_HMAC_SHA1_80");
                         switch_channel_set_variable(channel, "rtp_has_crypto", "srtp:dtls:AES_CM_128_HMAC_SHA1_80");
                 } else {
                         switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:sdes:%s", switch_channel_get_variable(channel, "rtp_has_crypto"));
                 }
                 switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
                 switch_event_fire(&fsevent);
         }
 
 
         return SWITCH_STATUS_SUCCESS;
 #endif
 }

Data Structures

Macros

Typedefs

Enumerations

Functions