#include <Spdp.h>

Inheritance diagram for OpenDDS::RTPS::Spdp:

Collaboration diagram for OpenDDS::RTPS::Spdp:

[legend]

Classes
class	IceConnect

class	SendStun

struct	SpdpTransport

Public Types
typedef DiscoveredParticipantMap::iterator	DiscoveredParticipantIter

typedef DiscoveredParticipantMap::const_iterator	DiscoveredParticipantConstIter

typedef std::pair< DDS::Security::ParticipantCryptoHandle, DDS::Security::SharedSecretHandle_var >	ParticipantCryptoInfoPair

Public Member Functions
typedef	OPENDDS_MAP_CMP (GUID_t, DiscoveredParticipant, GUID_tKeyLessThan) DiscoveredParticipantMap

	Spdp (DDS::DomainId_t domain, DCPS::GUID_t &guid, const DDS::DomainParticipantQos &qos, RtpsDiscovery *disco, XTypes::TypeLookupService_rch tls)

	Spdp (DDS::DomainId_t domain, const DCPS::GUID_t &guid, const DDS::DomainParticipantQos &qos, RtpsDiscovery *disco, XTypes::TypeLookupService_rch tls, DDS::Security::IdentityHandle id_handle, DDS::Security::PermissionsHandle perm_handle, DDS::Security::ParticipantCryptoHandle crypto_handle)

	~Spdp ()

const DCPS::GUID_t &	guid () const

void	init_bit (RcHandle< DCPS::BitSubscriber > bit_subscriber)

void	fini_bit ()

bool	get_default_locators (const DCPS::GUID_t &part_id, DCPS::LocatorSeq &target, bool &inlineQos)

bool	get_last_recv_locator (const DCPS::GUID_t &part_id, DCPS::LocatorSeq &target, bool &inlineQos)

void	signal_liveliness (DDS::LivelinessQosPolicyKind kind)

bool	initialized ()

void	shutdown ()

bool	shutting_down ()

bool	associated () const

bool	has_discovered_participant (const DCPS::GUID_t &guid) const

ACE_CDR::ULong	get_participant_flags (const DCPS::GUID_t &guid) const

Security::SecurityConfig_rch	get_security_config () const

DDS::Security::ParticipantCryptoHandle	crypto_handle () const

DDS::Security::ParticipantCryptoHandle	remote_crypto_handle (const DCPS::GUID_t &remote_participant) const

void	handle_auth_request (const DDS::Security::ParticipantStatelessMessage &msg)

void	send_handshake_request (const DCPS::GUID_t &guid, DiscoveredParticipant &dp)

void	handle_handshake_message (const DDS::Security::ParticipantStatelessMessage &msg)

bool	handle_participant_crypto_tokens (const DDS::Security::ParticipantVolatileMessageSecure &msg)

DDS::OctetSeq	local_participant_data_as_octets () const

void	handle_participant_data (DCPS::MessageId id, const ParticipantData_t &pdata, const DCPS::MonotonicTimePoint &now, const DCPS::SequenceNumber &seq, const ACE_INET_Addr &from, bool from_sedp)

bool	validateSequenceNumber (const DCPS::MonotonicTimePoint &now, const DCPS::SequenceNumber &seq, DiscoveredParticipantIter &iter)

void	process_handshake_deadlines (const DCPS::MonotonicTimePoint &tv)

void	process_handshake_resends (const DCPS::MonotonicTimePoint &tv)

void	write_secure_updates ()

void	write_secure_disposes ()

bool	is_security_enabled () const

bool	is_expectant_opendds (const GUID_t &participant) const

ParticipantCryptoInfoPair	lookup_participant_crypto_info (const DCPS::GUID_t &id) const

void	send_participant_crypto_tokens (const DCPS::GUID_t &id)

DDS::DomainId_t	get_domain_id () const

DDS::Security::PermissionsHandle	lookup_participant_permissions (const DCPS::GUID_t &id) const

AuthState	lookup_participant_auth_state (const GUID_t &id) const

void	process_participant_ice (const ParameterList &plist, const ParticipantData_t &pdata, const DCPS::GUID_t &guid)

const ParticipantData_t &	get_participant_data (const DCPS::GUID_t &guid) const

ParticipantData_t &	get_participant_data (const DCPS::GUID_t &guid)

DCPS::MonotonicTime_t	get_participant_discovered_at () const

DCPS::MonotonicTime_t	get_participant_discovered_at (const DCPS::GUID_t &guid) const

u_short	get_spdp_port () const

u_short	get_sedp_port () const

void	rtps_relay_only_now (bool f)

void	use_rtps_relay_now (bool f)

void	use_ice_now (bool f)

void	sedp_rtps_relay_address (const ACE_INET_Addr &address)

void	sedp_stun_server_address (const ACE_INET_Addr &address)

BuiltinEndpointSet_t	available_builtin_endpoints () const

DDS::Security::ExtendedBuiltinEndpointSet_t	available_extended_builtin_endpoints () const

DCPS::WeakRcHandle< ICE::Endpoint >	get_ice_endpoint_if_added ()

ParticipantData_t	build_local_pdata (bool always_in_the_clear, Security::DiscoveredParticipantDataKind kind)

DCPS::RcHandle< RtpsDiscoveryConfig >	config () const

void	spdp_rtps_relay_address_change ()

void	append_transport_statistics (DCPS::TransportStatisticsSequence &seq)

void	ignore_domain_participant (const GUID_t &ignoreId)

void	remove_domain_participant (const GUID_t &removeId)

bool	update_domain_participant_qos (const DDS::DomainParticipantQos &qos)

bool	has_domain_participant (const GUID_t &ignoreId) const

DCPS::TopicStatus	assert_topic (GUID_t &topicId, const char topicName, const char dataTypeName, const DDS::TopicQos &qos, bool hasDcpsKey, DCPS::TopicCallbacks *topic_callbacks)

DCPS::TopicStatus	find_topic (const char *topicName, CORBA::String_out dataTypeName, DDS::TopicQos_out qos, GUID_t &topicId)

DCPS::TopicStatus	remove_topic (const GUID_t &topicId)

void	ignore_topic (const GUID_t &ignoreId)

bool	update_topic_qos (const GUID_t &topicId, const DDS::TopicQos &qos)

GUID_t	add_publication (const GUID_t &topicId, DCPS::DataWriterCallbacks_rch publication, const DDS::DataWriterQos &qos, const DCPS::TransportLocatorSeq &transInfo, const DDS::PublisherQos &publisherQos, const XTypes::TypeInformation &type_info)

void	remove_publication (const GUID_t &publicationId)

void	ignore_publication (const GUID_t &ignoreId)

bool	update_publication_qos (const GUID_t &publicationId, const DDS::DataWriterQos &qos, const DDS::PublisherQos &publisherQos)

void	update_publication_locators (const GUID_t &publicationId, const DCPS::TransportLocatorSeq &transInfo)

GUID_t	add_subscription (const GUID_t &topicId, DCPS::DataReaderCallbacks_rch subscription, const DDS::DataReaderQos &qos, const DCPS::TransportLocatorSeq &transInfo, const DDS::SubscriberQos &subscriberQos, const char filterClassName, const char filterExpr, const DDS::StringSeq &params, const XTypes::TypeInformation &type_info)

void	remove_subscription (const GUID_t &subscriptionId)

void	ignore_subscription (const GUID_t &ignoreId)

bool	update_subscription_qos (const GUID_t &subscriptionId, const DDS::DataReaderQos &qos, const DDS::SubscriberQos &subscriberQos)

bool	update_subscription_params (const GUID_t &subId, const DDS::StringSeq &params)

void	update_subscription_locators (const GUID_t &subId, const DCPS::TransportLocatorSeq &transInfo)

RcHandle< DCPS::TransportInst >	sedp_transport_inst () const

void	request_remote_complete_type_objects (const GUID_t &remote_entity, const XTypes::TypeInformation &remote_type_info, DCPS::TypeObjReqCond &cond)

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Public Member Functions inherited from OpenDDS::ICE::AgentInfoListener
virtual	~AgentInfoListener ()

Protected Member Functions
Sedp &	endpoint_manager ()

void	purge_discovered_participant (const DiscoveredParticipantIter &iter)

void	enqueue_location_update_i (DiscoveredParticipantIter iter, DCPS::ParticipantLocation mask, const ACE_INET_Addr &from, const char *reason)

void	process_location_updates_i (const DiscoveredParticipantIter &iter, const char *reason, bool force_publish=false)

void	publish_location_update_i (const DiscoveredParticipantIter &iter)

bool	announce_domain_participant_qos ()

Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Private Member Functions
typedef	OPENDDS_MAP_CMP (GUID_t, DDS::Security::AuthRequestMessageToken, GUID_tKeyLessThan) PendingRemoteAuthTokenMap

void	init (DDS::DomainId_t domain, DCPS::GUID_t &guid, const DDS::DomainParticipantQos &qos, XTypes::TypeLookupService_rch tls)

void	data_received (const DataSubmessage &data, const ParameterList &plist, const ACE_INET_Addr &from)

void	match_unauthenticated (const DiscoveredParticipantIter &dp_iter)

DDS::ParticipantBuiltinTopicData	get_part_bit_data (bool secure) const

bool	secure_part_user_data () const

void	update_rtps_relay_application_participant_i (DiscoveredParticipantIter iter, bool new_participant)

DDS::ReturnCode_t	send_handshake_message (const DCPS::GUID_t &guid, DiscoveredParticipant &dp, const DDS::Security::ParticipantStatelessMessage &msg)

DCPS::MonotonicTimePoint	schedule_handshake_resend (const DCPS::TimeDuration &time, const DCPS::GUID_t &guid)

bool	match_authenticated (const DCPS::GUID_t &guid, DiscoveredParticipantIter &iter)

void	attempt_authentication (const DiscoveredParticipantIter &iter, bool from_discovery)

void	update_agent_info (const DCPS::GUID_t &local_guid, const ICE::AgentInfo &agent_info)

void	remove_agent_info (const DCPS::GUID_t &local_guid)

typedef	OPENDDS_MULTIMAP (DCPS::MonotonicTimePoint, DCPS::GUID_t) TimeQueue

void	remove_lease_expiration_i (DiscoveredParticipantIter iter)

void	update_lease_expiration_i (DiscoveredParticipantIter iter, const DCPS::MonotonicTimePoint &now)

void	process_lease_expirations (const DCPS::MonotonicTimePoint &now)

void	start_ice (DCPS::WeakRcHandle< ICE::Endpoint > endpoint, DCPS::GUID_t remote, BuiltinEndpointSet_t avail, DDS::Security::ExtendedBuiltinEndpointSet_t extended_avail, const ICE::AgentInfo &agent_info)

void	stop_ice (DCPS::WeakRcHandle< ICE::Endpoint > endpoint, DCPS::GUID_t remote, BuiltinEndpointSet_t avail, DDS::Security::ExtendedBuiltinEndpointSet_t extended_avail)

void	purge_handshake_deadlines (DiscoveredParticipantIter iter)

void	purge_handshake_resends (DiscoveredParticipantIter iter)

void	set_auth_state (DiscoveredParticipant &dp, AuthState state)

Private Attributes
ACE_Thread_Mutex	lock_

DCPS::RcHandle< DCPS::BitSubscriber >	bit_subscriber_

DDS::DomainParticipantQos	qos_

DiscoveredParticipantMap	participants_

RtpsDiscovery *	disco_

DCPS::RcHandle< RtpsDiscoveryConfig >	config_

const double	quick_resend_ratio_

const DCPS::TimeDuration	min_resend_delay_

DCPS::TimeDuration	lease_duration_

DCPS::TimeDuration	lease_extension_

XTypes::TypeLookupService_rch	type_lookup_service_

const DDS::DomainId_t	domain_

DCPS::GUID_t	guid_

const DCPS::MonotonicTime_t	participant_discovered_at_

bool	is_application_participant_

DCPS::RcHandle< SpdpTransport >	tport_

AtomicBool	initialized_flag_
	Spdp initialized. More...

bool	eh_shutdown_

DCPS::ConditionVariable< ACE_Thread_Mutex >	shutdown_cond_

AtomicBool	shutdown_flag_
	Spdp shutting down. More...

BuiltinEndpointSet_t	available_builtin_endpoints_

DCPS::RcHandle< Sedp >	sedp_

TimeQueue	lease_expirations_

DDS::Security::ExtendedBuiltinEndpointSet_t	available_extended_builtin_endpoints_

Security::SecurityConfig_rch	security_config_

bool	security_enabled_

DCPS::SequenceNumber	stateless_sequence_number_

DDS::Security::IdentityHandle	identity_handle_

DDS::Security::PermissionsHandle	permissions_handle_

DDS::Security::ParticipantCryptoHandle	crypto_handle_

DDS::Security::IdentityToken	identity_token_

DDS::Security::IdentityStatusToken	identity_status_token_

DDS::Security::PermissionsToken	permissions_token_

DDS::Security::PermissionsCredentialToken	permissions_credential_token_

DDS::Security::ParticipantSecurityAttributes	participant_sec_attr_

DCPS::RcHandle< ICE::Agent >	ice_agent_

TimeQueue	handshake_deadlines_

TimeQueue	handshake_resends_

size_t	n_participants_in_authentication_

Friends
class	Sedp

class	::DDS_TEST

Detailed Description

Each instance of class Spdp represents the implementation of the RTPS Simple Participant Discovery Protocol for a single local DomainParticipant.

Definition at line 61 of file Spdp.h.

Member Typedef Documentation

◆ DiscoveredParticipantConstIter

typedef DiscoveredParticipantMap::const_iterator OpenDDS::RTPS::Spdp::DiscoveredParticipantConstIter

Definition at line 71 of file Spdp.h.

◆ DiscoveredParticipantIter

typedef DiscoveredParticipantMap::iterator OpenDDS::RTPS::Spdp::DiscoveredParticipantIter

Definition at line 70 of file Spdp.h.

◆ ParticipantCryptoInfoPair

typedef std::pair<DDS::Security::ParticipantCryptoHandle, DDS::Security::SharedSecretHandle_var> OpenDDS::RTPS::Spdp::ParticipantCryptoInfoPair

Definition at line 165 of file Spdp.h.

Constructor & Destructor Documentation

◆ Spdp() [1/2]

OpenDDS::RTPS::Spdp::Spdp	(	DDS::DomainId_t	domain,
		DCPS::GUID_t &	guid,
		const DDS::DomainParticipantQos &	qos,
		RtpsDiscovery *	disco,
		XTypes::TypeLookupService_rch	tls
	)

Definition at line 219 of file Spdp.cpp.

References ACE_GUARD, init(), lock_, and participant_sec_attr_.

   : qos_(qos)
   , disco_(disco)
   , config_(disco_->config())
   , quick_resend_ratio_(disco_->config()->quick_resend_ratio())
   , min_resend_delay_(disco_->config()->min_resend_delay())
   , lease_duration_(disco_->config()->lease_duration())
   , lease_extension_(disco_->config()->lease_extension())
   , domain_(domain)
   , guid_(guid)
   , participant_discovered_at_(MonotonicTimePoint::now().to_monotonic_time())
   , is_application_participant_(false)
   , tport_(DCPS::make_rch<SpdpTransport>(rchandle_from(this)))
   , initialized_flag_(false)
   , eh_shutdown_(false)
   , shutdown_cond_(lock_)
   , shutdown_flag_(false)
   , available_builtin_endpoints_(0)
   , sedp_(DCPS::make_rch<Sedp>(guid_, DCPS::ref(*this), DCPS::ref(lock_)))
 #ifdef OPENDDS_SECURITY
   , available_extended_builtin_endpoints_(0)
   , security_config_()
   , security_enabled_(false)
   , identity_handle_(DDS::HANDLE_NIL)
   , permissions_handle_(DDS::HANDLE_NIL)
   , crypto_handle_(DDS::HANDLE_NIL)
   , ice_agent_(ICE::Agent::instance())
   , n_participants_in_authentication_(0)
 #endif
 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   init(domain, guid, qos, tls);
 
 #ifdef OPENDDS_SECURITY
   init_participant_sec_attributes(participant_sec_attr_);
 #endif
 
 }

◆ Spdp() [2/2]

OpenDDS::RTPS::Spdp::Spdp	(	DDS::DomainId_t	domain,
		const DCPS::GUID_t &	guid,
		const DDS::DomainParticipantQos &	qos,
		RtpsDiscovery *	disco,
		XTypes::TypeLookupService_rch	tls,
		DDS::Security::IdentityHandle	id_handle,
		DDS::Security::PermissionsHandle	perm_handle,
		DDS::Security::ParticipantCryptoHandle	crypto_handle
	)

Definition at line 264 of file Spdp.cpp.

References access(), ACE_ERROR, ACE_GUARD, ACE_TEXT(), DDS::Security::SecurityException::code, guid_, identity_handle_, identity_status_token_, identity_token_, init(), LM_ERROR, lock_, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, participant_sec_attr_, permissions_credential_token_, permissions_handle_, permissions_token_, security_config_, and sedp_.

   : qos_(qos)
   , disco_(disco)
   , config_(disco_->config())
   , quick_resend_ratio_(disco_->config()->quick_resend_ratio())
   , min_resend_delay_(disco_->config()->min_resend_delay())
   , lease_duration_(disco_->config()->lease_duration())
   , lease_extension_(disco_->config()->lease_extension())
   , domain_(domain)
   , guid_(guid)
   , participant_discovered_at_(MonotonicTimePoint::now().to_monotonic_time())
   , is_application_participant_(false)
   , tport_(DCPS::make_rch<SpdpTransport>(rchandle_from(this)))
   , initialized_flag_(false)
   , eh_shutdown_(false)
   , shutdown_cond_(lock_)
   , shutdown_flag_(false)
   , available_builtin_endpoints_(0)
   , sedp_(DCPS::make_rch<Sedp>(guid_, DCPS::ref(*this), DCPS::ref(lock_)))
   , available_extended_builtin_endpoints_(0)
   , security_config_(Security::SecurityRegistry::instance()->default_config())
   , security_enabled_(security_config_->get_authentication() && security_config_->get_access_control() &&
     security_config_->get_crypto_key_factory() && security_config_->get_crypto_key_exchange())
   , identity_handle_(identity_handle)
   , permissions_handle_(perm_handle)
   , crypto_handle_(crypto_handle)
   , ice_agent_(ICE::Agent::instance())
   , n_participants_in_authentication_(0)
 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   init(domain, guid_, qos, tls);
 
   DDS::Security::Authentication_var auth = security_config_->get_authentication();
   DDS::Security::AccessControl_var access = security_config_->get_access_control();
 
   DDS::Security::SecurityException se = {"", 0, 0};
 
   if (!auth->get_identity_token(identity_token_, identity_handle_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("unable to get identity token. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to get identity token");
   }
   if (!auth->get_identity_status_token(identity_status_token_, identity_handle_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("unable to get identity status token. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to get identity status token");
   }
   if (!access->get_permissions_token(permissions_token_, permissions_handle_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("unable to get permissions handle. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to get permissions token");
   }
   if (!access->get_permissions_credential_token(permissions_credential_token_, permissions_handle_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("unable to get permissions credential handle. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to get permissions credential token");
   }
 
   if (!auth->set_permissions_credential_and_token(identity_handle_, permissions_credential_token_, permissions_token_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("unable to set permissions credential and token. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to set permissions credential and token");
   }
 
   init_participant_sec_attributes(participant_sec_attr_);
 
   if (!access->get_participant_sec_attributes(permissions_handle_, participant_sec_attr_, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
       ACE_TEXT("Spdp::Spdp() - ")
       ACE_TEXT("failed to retrieve participant security attributes. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     throw std::runtime_error("unable to retrieve participant security attributes");
   }
 
   sedp_->init_security(identity_handle, perm_handle, crypto_handle);
 }

◆ ~Spdp()

OpenDDS::RTPS::Spdp::~Spdp ( )

Definition at line 422 of file Spdp.cpp.

423 {

424 }

Member Function Documentation

◆ add_publication()

GUID_t OpenDDS::RTPS::Spdp::add_publication	(	const GUID_t &	topicId,
		DCPS::DataWriterCallbacks_rch	publication,
		const DDS::DataWriterQos &	qos,
		const DCPS::TransportLocatorSeq &	transInfo,
		const DDS::PublisherQos &	publisherQos,
		const XTypes::TypeInformation &	type_info
	)

inline

Definition at line 260 of file Spdp.h.

   {
     return endpoint_manager().add_publication(topicId, publication, qos,
                                               transInfo, publisherQos, type_info);
   }

◆ add_subscription()

GUID_t OpenDDS::RTPS::Spdp::add_subscription	(	const GUID_t &	topicId,
		DCPS::DataReaderCallbacks_rch	subscription,
		const DDS::DataReaderQos &	qos,
		const DCPS::TransportLocatorSeq &	transInfo,
		const DDS::SubscriberQos &	subscriberQos,
		const char *	filterClassName,
		const char *	filterExpr,
		const DDS::StringSeq &	params,
		const XTypes::TypeInformation &	type_info
	)

inline

Definition at line 297 of file Spdp.h.

   {
     return endpoint_manager().add_subscription(topicId, subscription, qos, transInfo,
       subscriberQos, filterClassName, filterExpr, params, type_info);
   }

◆ announce_domain_participant_qos()

bool OpenDDS::RTPS::Spdp::announce_domain_participant_qos ( )

protected

Definition at line 2290 of file Spdp.cpp.

References is_security_enabled(), OpenDDS::RTPS::Spdp::SpdpTransport::SEND_DIRECT, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_MULTICAST, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_RELAY, and write_secure_updates().

Referenced by update_domain_participant_qos().

 {
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled()) {
     write_secure_updates();
   }
 #endif
 
   return true;
 }

◆ append_transport_statistics()

void OpenDDS::RTPS::Spdp::append_transport_statistics ( DCPS::TransportStatisticsSequence & seq )

Definition at line 2802 of file Spdp.cpp.

References ACE_GUARD, OpenDDS::DCPS::append(), lock_, sedp_, and tport_.

 {
   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     append(seq, tport_->transport_statistics_);
     tport_->transport_statistics_.clear();
   }
   sedp_->append_transport_statistics(seq);
 }

◆ assert_topic()

DCPS::TopicStatus OpenDDS::RTPS::Spdp::assert_topic	(	GUID_t &	topicId,
		const char *	topicName,
		const char *	dataTypeName,
		const DDS::TopicQos &	qos,
		bool	hasDcpsKey,
		DCPS::TopicCallbacks *	topic_callbacks
	)

Definition at line 4680 of file Spdp.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::RTPS::Sedp::assert_topic(), OpenDDS::DCPS::DCPS_debug_level, endpoint_manager(), LM_ERROR, and OpenDDS::DCPS::PRECONDITION_NOT_MET.

 {
   if (std::strlen(topicName) > 256 || std::strlen(dataTypeName) > 256) {
     if (DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR LocalParticipant::assert_topic() - ")
                  ACE_TEXT("topic or type name length limit (256) exceeded\n")));
     }
     return DCPS::PRECONDITION_NOT_MET;
   }
 
   return endpoint_manager().assert_topic(topicId, topicName, dataTypeName, qos, hasDcpsKey, topic_callbacks);
 }

◆ associated()

bool OpenDDS::RTPS::Spdp::associated ( ) const

Definition at line 3682 of file Spdp.cpp.

References participants_.

Referenced by OpenDDS::RTPS::Sedp::write_participant_message_data(), OpenDDS::RTPS::Sedp::write_participant_message_data_secure(), OpenDDS::RTPS::Sedp::write_publication_data_secure(), OpenDDS::RTPS::Sedp::write_publication_data_unsecure(), OpenDDS::RTPS::Sedp::write_subscription_data_secure(), and OpenDDS::RTPS::Sedp::write_subscription_data_unsecure().

 {
   return !participants_.empty();
 }

◆ attempt_authentication()

void OpenDDS::RTPS::Spdp::attempt_authentication	(	const DiscoveredParticipantIter &	iter,
		bool	from_discovery
	)

private

Definition at line 1336 of file Spdp.cpp.

Referenced by handle_auth_request(), and handle_participant_data().

 {
   const DCPS::GUID_t& guid = iter->first;
   DiscoveredParticipant& dp = iter->second;
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication "
       "for %C from_discovery=%d have_remote_token=%d auth_state=%d handshake_state=%d\n",
       DCPS::LogGuid(guid).c_str(),
       from_discovery, !(dp.remote_auth_request_token_ == DDS::Security::Token()),
       dp.auth_state_, dp.handshake_state_));
   }
 
   dp.handshake_resend_falloff_.set(config_->auth_resend_period());
 
   if (!from_discovery && dp.handshake_state_ != HANDSHAKE_STATE_DONE) {
     // Ignore auth reqs when already in progress.
     schedule_handshake_resend(DCPS::TimeDuration::zero_value, guid);
     return;
   }
 
   // Reset.
   purge_handshake_deadlines(iter);
   dp.handshake_deadline_ = DCPS::MonotonicTimePoint::now() + config_->max_auth_time();
   handshake_deadlines_.insert(std::make_pair(dp.handshake_deadline_, guid));
   tport_->handshake_deadline_task_->schedule(config_->max_auth_time());
 
   DDS::Security::Authentication_var auth = security_config_->get_authentication();
   DDS::Security::SecurityException se = {"", 0, 0};
 
   const DDS::Security::ValidationResult_t vr = auth->validate_remote_identity(
     dp.identity_handle_, dp.local_auth_request_token_, dp.remote_auth_request_token_,
     identity_handle_, dp.identity_token_, guid, se);
 
   dp.have_auth_req_msg_ = !(dp.local_auth_request_token_ == DDS::Security::Token());
   if (dp.have_auth_req_msg_) {
     dp.auth_req_msg_.message_identity.source_guid = guid_;
     dp.auth_req_msg_.message_identity.sequence_number = (++stateless_sequence_number_).getValue();
     dp.auth_req_msg_.message_class_id = DDS::Security::GMCLASSID_SECURITY_AUTH_REQUEST;
     dp.auth_req_msg_.destination_participant_guid = guid;
     dp.auth_req_msg_.destination_endpoint_guid = GUID_UNKNOWN;
     dp.auth_req_msg_.source_endpoint_guid = GUID_UNKNOWN;
     dp.auth_req_msg_.related_message_identity.source_guid = GUID_UNKNOWN;
     dp.auth_req_msg_.related_message_identity.sequence_number = 0;
     dp.auth_req_msg_.message_data.length(1);
     dp.auth_req_msg_.message_data[0] = dp.local_auth_request_token_;
     // Send the auth req immediately to reset the remote if they are
     // still authenticated with us.
     if (sedp_->write_stateless_message(dp.auth_req_msg_, make_id(guid, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER)) != DDS::RETCODE_OK) {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::attempt_authentication() - ")
                    ACE_TEXT("Unable to write auth req message.\n")));
       }
     } else {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication() - ")
                    ACE_TEXT("Sent auth req message for participant: %C\n"),
                    DCPS::LogGuid(guid).c_str()));
       }
     }
     schedule_handshake_resend(dp.handshake_resend_falloff_.get(), guid);
   }
 
   switch (vr) {
   case DDS::Security::VALIDATION_OK: {
     set_auth_state(dp, AUTH_STATE_AUTHENTICATED);
     dp.handshake_state_ = HANDSHAKE_STATE_DONE;
     purge_handshake_deadlines(iter);
     return;
   }
   case DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE: {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication() - ")
                  ACE_TEXT("Attempting authentication (expecting request) for participant: %C\n"),
                  DCPS::LogGuid(guid).c_str()));
     }
     dp.handshake_state_ = HANDSHAKE_STATE_BEGIN_HANDSHAKE_REPLY;
     dp.is_requester_ = true;
     return; // We'll need to wait for an inbound handshake request from the remote participant
   }
   case DDS::Security::VALIDATION_PENDING_HANDSHAKE_REQUEST: {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication() - ")
                  ACE_TEXT("Attempting authentication (sending request/expecting reply) for participant: %C\n"),
                  DCPS::LogGuid(guid).c_str()));
     }
     dp.handshake_state_ = HANDSHAKE_STATE_BEGIN_HANDSHAKE_REQUEST;
     send_handshake_request(guid, dp);
     return;
   }
   case DDS::Security::VALIDATION_FAILED: {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication() - ")
                  ACE_TEXT("Remote participant identity is invalid. Security Exception[%d.%d]: %C\n"),
                  se.code, se.minor_code, se.message.in()));
     }
     set_auth_state(dp, AUTH_STATE_UNAUTHENTICATED);
     dp.handshake_state_ = HANDSHAKE_STATE_DONE;
     purge_handshake_deadlines(iter);
     return;
   }
   default: {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::attempt_authentication() - ")
                  ACE_TEXT("Unexpected return value while validating remote identity. Security Exception[%d.%d]: %C\n"),
                  se.code, se.minor_code, se.message.in()));
     }
     set_auth_state(dp, AUTH_STATE_UNAUTHENTICATED);
     dp.handshake_state_ = HANDSHAKE_STATE_DONE;
     purge_handshake_deadlines(iter);
     return;
   }
   }
 }

◆ available_builtin_endpoints()

BuiltinEndpointSet_t OpenDDS::RTPS::Spdp::available_builtin_endpoints ( ) const

inline

Definition at line 201 of file Spdp.h.

201 { return available_builtin_endpoints_; }

OpenDDS::RTPS::Spdp::available_builtin_endpoints_

BuiltinEndpointSet_t available_builtin_endpoints_

Definition: Spdp.h:605

◆ available_extended_builtin_endpoints()

DDS::Security::ExtendedBuiltinEndpointSet_t OpenDDS::RTPS::Spdp::available_extended_builtin_endpoints ( ) const

inline

Definition at line 203 of file Spdp.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), and OpenDDS::RTPS::Sedp::init().

   {
     return available_extended_builtin_endpoints_;
   }

◆ build_local_pdata()

ParticipantData_t OpenDDS::RTPS::Spdp::build_local_pdata	(	bool	always_in_the_clear,
		Security::DiscoveredParticipantDataKind	kind
	)

Definition at line 2201 of file Spdp.cpp.

References ACE_ERROR, ACE_TEXT(), available_builtin_endpoints_, available_extended_builtin_endpoints_, config_, OpenDDS::DCPS::DCPS_debug_level, domain_, get_part_bit_data(), guid_, OpenDDS::DCPS::GUID_t::guidPrefix, identity_status_token_, identity_token_, is_application_participant_, lease_duration_, LM_ERROR, OpenDDS::RTPS::LOCATOR_KIND_UDPv4, participant_discovered_at_, participant_sec_attr_, permissions_token_, DDS::Security::ParticipantSecurityAttributes::plugin_participant_attributes, DDS::DomainParticipantQos::property, OpenDDS::RTPS::PROTOCOLVERSION, qos_, ACE_Time_Value::sec(), OpenDDS::RTPS::security_attributes_to_bitmask(), sedp_, OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::RTPS::VENDORID_OPENDDS.

Referenced by OpenDDS::RTPS::Sedp::write_durable_dcps_participant_secure(), and write_secure_updates().

 {
   // The RTPS spec has no constants for the builtinTopics{Writer,Reader}
 
   // This locator list should not be empty, but we won't actually be using it.
   // The OpenDDS publication/subscription data will have locators included.
   DCPS::LocatorSeq nonEmptyList(1);
   nonEmptyList.length(1);
   nonEmptyList[0].kind = LOCATOR_KIND_UDPv4;
   nonEmptyList[0].port = 12345;
   std::memset(nonEmptyList[0].address, 0, 12);
   nonEmptyList[0].address[12] = 127;
   nonEmptyList[0].address[13] = 0;
   nonEmptyList[0].address[14] = 0;
   nonEmptyList[0].address[15] = 1;
 
   const GuidPrefix_t& gp = guid_.guidPrefix;
 
   const DCPS::LocatorSeq unicast_locators = sedp_->unicast_locators();
   const DCPS::LocatorSeq multicast_locators = sedp_->multicast_locators();
 
   if (unicast_locators.length() == 0 && multicast_locators.length() == 0) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_ERROR,
                 ACE_TEXT("(%P|%t) ERROR: ")
                 ACE_TEXT("Spdp::build_local_pdata: ")
                 ACE_TEXT("no locators\n")));
     }
   }
 
 #ifdef OPENDDS_SECURITY
   const Security::SPDPdiscoveredParticipantData pdata = {
     kind,
     { // ParticipantBuiltinTopicDataSecure
       { // ParticipantBuiltinTopicData (security enhanced)
         get_part_bit_data(!always_in_the_clear),
         identity_token_,
         permissions_token_,
         qos_.property,
         {
           security_attributes_to_bitmask(participant_sec_attr_),
           participant_sec_attr_.plugin_participant_attributes
         },
         available_extended_builtin_endpoints_
       },
       identity_status_token_
     },
 #else
   const SPDPdiscoveredParticipantData pdata = {
     get_part_bit_data(false),
 #endif
     { // ParticipantProxy_t
       domain_
       , ""
       , PROTOCOLVERSION
       , {gp[0], gp[1], gp[2], gp[3], gp[4], gp[5],
        gp[6], gp[7], gp[8], gp[9], gp[10], gp[11]}
       , VENDORID_OPENDDS
       , false /*expectsIQoS*/
       , available_builtin_endpoints_
       , 0
       , unicast_locators
       , multicast_locators
       , nonEmptyList /*defaultMulticastLocatorList*/
       , nonEmptyList /*defaultUnicastLocatorList*/
       , {0 /*manualLivelinessCount*/}   //FUTURE: implement manual liveliness
       , qos_.property
       , {config_->participant_flags()} // opendds_participant_flags
       , is_application_participant_
 #ifdef OPENDDS_SECURITY
       , available_extended_builtin_endpoints_
 #endif
     },
     { // Duration_t (leaseDuration)
       static_cast<CORBA::Long>(lease_duration_.value().sec()),
       0 // we are not supporting fractional seconds in the lease duration
     },
     participant_discovered_at_
   };
 
   return pdata;
 }

◆ config()

DCPS::RcHandle<RtpsDiscoveryConfig> OpenDDS::RTPS::Spdp::config ( ) const

inline

Definition at line 218 of file Spdp.h.

Referenced by OpenDDS::RTPS::Sedp::add_publication_i(), and OpenDDS::RTPS::Sedp::add_subscription_i().

218 { return config_; }

OpenDDS::RTPS::Spdp::config_

DCPS::RcHandle< RtpsDiscoveryConfig > config_

Definition: Spdp.h:384

◆ crypto_handle()

DDS::Security::ParticipantCryptoHandle OpenDDS::RTPS::Spdp::crypto_handle ( ) const

inline

Definition at line 129 of file Spdp.h.

Referenced by OpenDDS::RTPS::Sedp::init().

129 { return crypto_handle_; }

OpenDDS::RTPS::Spdp::crypto_handle_

DDS::Security::ParticipantCryptoHandle crypto_handle_

Definition: Spdp.h:625

◆ data_received()

void OpenDDS::RTPS::Spdp::data_received	(	const DataSubmessage &	data,
		const ParameterList &	plist,
		const ACE_INET_Addr &	from
	)

private

Definition at line 1048 of file Spdp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), DDS::Security::ParticipantBuiltinTopicData::base, DDS::Security::ParticipantBuiltinTopicDataSecure::base, OpenDDS::DCPS::BUILTIN_TOPIC_KEY_UNKNOWN, config_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::Security::SPDPdiscoveredParticipantData::ddsParticipantDataSecure, OpenDDS::Security::SPDPdiscoveredParticipantData::discoveredAt, OpenDDS::DCPS::DISPOSE_INSTANCE, domain_, OpenDDS::RTPS::ParticipantProxy_t::domainId, OpenDDS::RTPS::ParameterListConverter::from_param_list(), guid(), guid_, OpenDDS::RTPS::ParticipantProxy_t::guidPrefix, handle_participant_data(), initialized_flag_, OpenDDS::RTPS::DataSubmessage::inlineQos, OpenDDS::RTPS::ip_in_AgentInfo(), OpenDDS::RTPS::ip_in_locator_list(), is_security_enabled(), LM_ERROR, LM_WARNING, lock_, OpenDDS::DCPS::make_part_guid(), OpenDDS::RTPS::ParticipantProxy_t::metatrafficUnicastLocatorList, OpenDDS::Security::SPDPdiscoveredParticipantData::participantProxy, process_participant_ice(), ACE_Guard< ACE_LOCK >::release(), OpenDDS::DCPS::SAMPLE_DATA, shutdown_flag_, OpenDDS::RTPS::to_opendds_seqnum(), and OpenDDS::RTPS::DataSubmessage::writerSN.

 {
   ACE_Guard<ACE_Thread_Mutex> guard(lock_);
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   const MonotonicTimePoint now = MonotonicTimePoint::now();
   ParticipantData_t pdata;
 
   pdata.participantProxy.domainId = domain_;
   pdata.discoveredAt = now.to_monotonic_time();
 #ifdef OPENDDS_SECURITY
   pdata.ddsParticipantDataSecure.base.base.key = DCPS::BUILTIN_TOPIC_KEY_UNKNOWN;
 #endif
 
   if (!ParameterListConverter::from_param_list(plist, pdata)) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::data_received - ")
         ACE_TEXT("failed to convert from ParameterList to ")
         ACE_TEXT("SPDPdiscoveredParticipantData\n")));
     }
     return;
   }
 
   // Remote domain ID, if populated, has to match
   if (pdata.participantProxy.domainId != domain_) {
     return;
   }
 
   const GUID_t guid = DCPS::make_part_guid(pdata.participantProxy.guidPrefix);
   if (guid == guid_) {
     // About us, stop.
     return;
   }
 
   const DCPS::MessageId msg_id = (data.inlineQos.length() && disposed(data.inlineQos)) ? DCPS::DISPOSE_INSTANCE : DCPS::SAMPLE_DATA;
 
 #ifdef OPENDDS_SECURITY
   const bool relay_in_use = (config_->rtps_relay_only() || config_->use_rtps_relay());
   const bool from_relay = relay_in_use && (from == config_->spdp_rtps_relay_address());
 
   if (config_->check_source_ip() && msg_id == DCPS::SAMPLE_DATA && !from_relay && !ip_in_locator_list(from, pdata.participantProxy.metatrafficUnicastLocatorList) && !ip_in_AgentInfo(from, plist)) {
     if (DCPS::DCPS_debug_level >= 8) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) Spdp::data_received - dropped IP: %C\n"), DCPS::LogAddr(from).c_str()));
     }
     return;
   }
 
   const bool security_enabled = is_security_enabled();
   guard.release();
 
   if (!security_enabled) {
     process_participant_ice(plist, pdata, guid);
   }
 #elif !defined OPENDDS_SAFETY_PROFILE
   const bool relay_in_use = (config_->rtps_relay_only() || config_->use_rtps_relay());
   const bool from_relay = relay_in_use && (from == config_->spdp_rtps_relay_address());
 
   const bool check_source_ip = config_->check_source_ip();
   guard.release();
 
   if (check_source_ip && msg_id == DCPS::SAMPLE_DATA && !from_relay && !ip_in_locator_list(from, pdata.participantProxy.metatrafficUnicastLocatorList)) {
     if (DCPS::DCPS_debug_level >= 8) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) Spdp::data_received - IP not in locator list: %C\n"), DCPS::LogAddr(from).c_str()));
     }
     return;
   }
 #else
   guard.release();
 #endif
 
   handle_participant_data(msg_id, pdata, now, to_opendds_seqnum(data.writerSN), from, false);
 }

◆ endpoint_manager()

Sedp& OpenDDS::RTPS::Spdp::endpoint_manager ( )

inlineprotected

Definition at line 354 of file Spdp.h.

References init(), and OpenDDS::RTPS::OPENDDS_MAP_CMP().

Referenced by assert_topic(), ignore_domain_participant(), and purge_discovered_participant().

354 { return *sedp_; }

OpenDDS::RTPS::Spdp::sedp_

DCPS::RcHandle< Sedp > sedp_

Definition: Spdp.h:606

◆ enqueue_location_update_i()

void OpenDDS::RTPS::Spdp::enqueue_location_update_i	(	DiscoveredParticipantIter	iter,
		DCPS::ParticipantLocation	mask,
		const ACE_INET_Addr &	from,
		const char *	reason
	)

protected

Definition at line 460 of file Spdp.cpp.

References ACE_DEBUG, OpenDDS::DCPS::LogGuid::c_str(), LM_DEBUG, OpenDDS::DCPS::log_bits, and OpenDDS::DCPS::TimePoint_T< SystemClock >::now().

Referenced by handle_participant_data(), process_participant_ice(), rtps_relay_only_now(), use_ice_now(), and use_rtps_relay_now().

 {
   // We have the global lock.
   iter->second.location_updates_.push_back(DiscoveredParticipant::LocationUpdate(mask, from, DCPS::SystemTimePoint::now()));
 
   if (DCPS::log_bits) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::enqueue_location_update_i: %@ for %C size=%B reason=%C\n", this, LogGuid(iter->first).c_str(), iter->second.location_updates_.size(), reason));
   }
 
 }

◆ find_topic()

DCPS::TopicStatus OpenDDS::RTPS::Spdp::find_topic	(	const char *	topicName,
		CORBA::String_out	dataTypeName,
		DDS::TopicQos_out	qos,
		GUID_t &	topicId
	)

inline

Definition at line 235 of file Spdp.h.

   {
     return endpoint_manager().find_topic(topicName, dataTypeName, qos, topicId);
   }

◆ fini_bit()

void OpenDDS::RTPS::Spdp::fini_bit ( )

Definition at line 2178 of file Spdp.cpp.

References bit_subscriber_, OpenDDS::RTPS::ParticipantProxy_t::vendorId, and OpenDDS::DCPS::VENDORID_OCI.

 {
   bit_subscriber_->clear();
 }

◆ get_default_locators()

bool OpenDDS::RTPS::Spdp::get_default_locators	(	const DCPS::GUID_t &	part_id,
		DCPS::LocatorSeq &	target,
		bool &	inlineQos
	)

Definition at line 3639 of file Spdp.cpp.

References participants_.

Referenced by OpenDDS::RTPS::Sedp::populate_transport_locator_sequence().

 {
   DiscoveredParticipantIter part_iter = participants_.find(part_id);
   if (part_iter == participants_.end()) {
     return false;
   } else {
     inlineQos = part_iter->second.pdata_.participantProxy.expectsInlineQos;
     DCPS::LocatorSeq& mc_source =
           part_iter->second.pdata_.participantProxy.defaultMulticastLocatorList;
     DCPS::LocatorSeq& uc_source =
           part_iter->second.pdata_.participantProxy.defaultUnicastLocatorList;
     CORBA::ULong mc_source_len = mc_source.length();
     CORBA::ULong uc_source_len = uc_source.length();
     CORBA::ULong target_len = target.length();
     target.length(mc_source_len + uc_source_len + target_len);
     // Copy multicast
     for (CORBA::ULong mci = 0; mci < mc_source.length(); ++mci) {
       target[target_len + mci] = mc_source[mci];
     }
     // Copy unicast
     for (CORBA::ULong uci = 0; uci < uc_source.length(); ++uci) {
       target[target_len + mc_source_len + uci] = uc_source[uci];
     }
   }
   return true;
 }

◆ get_domain_id()

DDS::DomainId_t OpenDDS::RTPS::Spdp::get_domain_id ( ) const

inline

Definition at line 169 of file Spdp.h.

Referenced by OpenDDS::RTPS::Sedp::get_domain_id(), OpenDDS::RTPS::Sedp::process_discovered_reader_data(), and OpenDDS::RTPS::Sedp::process_discovered_writer_data().

169 { return domain_; }

OpenDDS::RTPS::Spdp::domain_

const DDS::DomainId_t domain_

Definition: Spdp.h:392

◆ get_ice_endpoint_if_added()

DCPS::WeakRcHandle< ICE::Endpoint > OpenDDS::RTPS::Spdp::get_ice_endpoint_if_added ( )

Definition at line 612 of file Spdp.cpp.

References tport_.

Referenced by OpenDDS::RTPS::Sedp::DiscoveryWriter::write_dcps_participant_secure().

 {
   return tport_->ice_endpoint_added_ ? tport_->get_ice_endpoint() : DCPS::WeakRcHandle<ICE::Endpoint>();
 }

◆ get_last_recv_locator()

bool OpenDDS::RTPS::Spdp::get_last_recv_locator	(	const DCPS::GUID_t &	part_id,
		DCPS::LocatorSeq &	target,
		bool &	inlineQos
	)

Definition at line 3668 of file Spdp.cpp.

References OpenDDS::DCPS::address_to_locator(), and participants_.

Referenced by OpenDDS::RTPS::Sedp::populate_origination_locator().

 {
   DiscoveredParticipantIter pos = participants_.find(part_id);
   if (pos != participants_.end() && pos->second.last_recv_address_ != ACE_INET_Addr()) {
     inlineQos = pos->second.pdata_.participantProxy.expectsInlineQos;
     target.length(1);
     DCPS::address_to_locator(target[0], pos->second.last_recv_address_);
     return true;
   }
   return false;
 }

◆ get_part_bit_data()

DDS::ParticipantBuiltinTopicData OpenDDS::RTPS::Spdp::get_part_bit_data ( bool secure ) const

private

Get this participant's BIT data. user_data may be omitting depending on security settings.

Definition at line 4628 of file Spdp.cpp.

References qos_, secure_part_user_data(), and DDS::DomainParticipantQos::user_data.

Referenced by build_local_pdata(), and local_participant_data_as_octets().

 {
   bool include_user_data = true;
 #ifdef OPENDDS_SECURITY
   if (secure_part_user_data()) {
     include_user_data = secure;
   }
 #else
   ACE_UNUSED_ARG(secure);
 #endif
   DDS::ParticipantBuiltinTopicData bit_data;
   bit_data.key = DDS::BuiltinTopicKey_t();
   bit_data.user_data = include_user_data ? qos_.user_data : DDS::UserDataQosPolicy();
   return bit_data;
 }

◆ get_participant_data() [1/2]

const ParticipantData_t & OpenDDS::RTPS::Spdp::get_participant_data ( const DCPS::GUID_t & guid ) const

Definition at line 4449 of file Spdp.cpp.

References OpenDDS::DCPS::make_part_guid(), and participants_.

 {
   DiscoveredParticipantConstIter iter = participants_.find(make_part_guid(guid));
   return iter->second.pdata_;
 }

◆ get_participant_data() [2/2]

ParticipantData_t & OpenDDS::RTPS::Spdp::get_participant_data ( const DCPS::GUID_t & guid )

Definition at line 4455 of file Spdp.cpp.

References OpenDDS::DCPS::make_part_guid(), and participants_.

 {
   DiscoveredParticipantIter iter = participants_.find(make_part_guid(guid));
   return iter->second.pdata_;
 }

◆ get_participant_discovered_at() [1/2]

DCPS::MonotonicTime_t OpenDDS::RTPS::Spdp::get_participant_discovered_at ( ) const

Definition at line 4461 of file Spdp.cpp.

References participant_discovered_at_.

Referenced by OpenDDS::RTPS::Sedp::add_publication_i(), OpenDDS::RTPS::Sedp::add_subscription_i(), OpenDDS::RTPS::Sedp::process_discovered_reader_data(), OpenDDS::RTPS::Sedp::process_discovered_writer_data(), OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply(), and OpenDDS::RTPS::Sedp::TypeLookupRequestWriter::send_type_lookup_request().

 {
   return participant_discovered_at_;
 }

◆ get_participant_discovered_at() [2/2]

DCPS::MonotonicTime_t OpenDDS::RTPS::Spdp::get_participant_discovered_at ( const DCPS::GUID_t & guid ) const

Definition at line 4466 of file Spdp.cpp.

References OpenDDS::DCPS::make_part_guid(), and participants_.

 {
   const DiscoveredParticipantConstIter iter = participants_.find(make_part_guid(guid));
   return iter->second.discovered_at_.to_monotonic_time();
 }

◆ get_participant_flags()

ACE_CDR::ULong OpenDDS::RTPS::Spdp::get_participant_flags ( const DCPS::GUID_t & guid ) const

Definition at line 3693 of file Spdp.cpp.

References participants_, and OpenDDS::RTPS::PFLAGS_EMPTY.

Referenced by OpenDDS::RTPS::Sedp::process_discovered_reader_data(), and OpenDDS::RTPS::Sedp::process_discovered_writer_data().

 {
   const DiscoveredParticipantMap::const_iterator iter = participants_.find(guid);
   if (iter == participants_.end()) {
     return PFLAGS_EMPTY;
   }
   return is_opendds(iter->second.pdata_.participantProxy)
     ? iter->second.pdata_.participantProxy.opendds_participant_flags.bits : PFLAGS_EMPTY;
 }

◆ get_security_config()

Security::SecurityConfig_rch OpenDDS::RTPS::Spdp::get_security_config ( ) const

inline

Definition at line 128 of file Spdp.h.

128 { return security_config_; }

OpenDDS::RTPS::Spdp::security_config_

Security::SecurityConfig_rch security_config_

Definition: Spdp.h:618

◆ get_sedp_port()

u_short OpenDDS::RTPS::Spdp::get_sedp_port ( ) const

inline

Definition at line 187 of file Spdp.h.

187 { return sedp_->local_address().get_port_number(); }

OpenDDS::RTPS::Spdp::sedp_

DCPS::RcHandle< Sedp > sedp_

Definition: Spdp.h:606

◆ get_spdp_port()

u_short OpenDDS::RTPS::Spdp::get_spdp_port ( ) const

inline

Definition at line 185 of file Spdp.h.

185 { return tport_ ? tport_->uni_port_ : 0; }

OpenDDS::RTPS::Spdp::tport_

DCPS::RcHandle< SpdpTransport > tport_

Definition: Spdp.h:556

◆ guid()

const DCPS::GUID_t& OpenDDS::RTPS::Spdp::guid ( ) const

inline

Definition at line 94 of file Spdp.h.

Referenced by attempt_authentication(), data_received(), handle_auth_request(), OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), handle_participant_data(), send_handshake_message(), and send_handshake_request().

94 { return guid_; }

OpenDDS::RTPS::Spdp::guid_

DCPS::GUID_t guid_

Definition: Spdp.h:393

◆ handle_auth_request()

void OpenDDS::RTPS::Spdp::handle_auth_request ( const DDS::Security::ParticipantStatelessMessage & msg )

Definition at line 1142 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), attempt_authentication(), OpenDDS::DCPS::LogGuid::c_str(), DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::DCPS::ENTITYID_PARTICIPANT, guid(), OpenDDS::RTPS::Parameter::guid, guid_, initialized_flag_, LM_DEBUG, lock_, OpenDDS::DCPS::make_id(), DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, participants_, OpenDDS::RTPS::PID_PARTICIPANT_GUID, OpenDDS::DCPS::security_debug, sedp_, DDS::Security::MessageIdentity::sequence_number, shutdown_flag_, and DDS::Security::MessageIdentity::source_guid.

Referenced by OpenDDS::RTPS::Sedp::received_stateless_message().

 {
   const GUID_t guid = make_id(msg.message_identity.source_guid, DCPS::ENTITYID_PARTICIPANT);
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_auth_request() - ")
                ACE_TEXT("%C -> %C local %C\n"),
                DCPS::LogGuid(guid).c_str(),
                DCPS::LogGuid(msg.destination_participant_guid).c_str(),
                DCPS::LogGuid(guid_).c_str()));
   }
 
   // If this message wasn't intended for us, ignore handshake message
   if (msg.destination_participant_guid != guid_) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_auth_request() - ")
                  ACE_TEXT("Dropped not recipient\n")));
     }
     return;
   }
 
   if (msg.message_data.length() == 0) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_auth_request() - ")
                  ACE_TEXT("Dropped no data\n")));
     }
     return;
   }
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   if (sedp_->ignoring(guid)) {
     // Ignore, this is our domain participant or one that the user has
     // asked us to ignore.
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_auth_request() - ")
                  ACE_TEXT("Explicitly ignoring\n")));
     }
     return;
   }
 
 
   DiscoveredParticipantMap::iterator iter = participants_.find(guid);
 
   if (iter != participants_.end()) {
     if (msg.message_identity.sequence_number <= iter->second.auth_req_sequence_number_) {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_auth_request() - ")
                    ACE_TEXT("Dropped due to old sequence number\n")));
       }
       return;
     }
 
     iter->second.remote_auth_request_token_ = msg.message_data[0];
     iter->second.auth_req_sequence_number_ = msg.message_identity.sequence_number;
 
     attempt_authentication(iter, false);
   }
 }

◆ handle_handshake_message()

void OpenDDS::RTPS::Spdp::handle_handshake_message ( const DDS::Security::ParticipantStatelessMessage & msg )

Definition at line 1452 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::RTPS::DiscoveredParticipant::auth_state_, OpenDDS::RTPS::AUTH_STATE_AUTHENTICATED, OpenDDS::DCPS::LogGuid::c_str(), DDS::Security::SecurityException::code, config_, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER, OpenDDS::DCPS::ENTITYID_PARTICIPANT, DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE, guid_, OpenDDS::DCPS::GUID_UNKNOWN, DDS::HANDLE_NIL, OpenDDS::RTPS::DiscoveredParticipant::handshake_handle_, OpenDDS::RTPS::DiscoveredParticipant::handshake_msg_, OpenDDS::RTPS::DiscoveredParticipant::handshake_resend_falloff_, OpenDDS::RTPS::DiscoveredParticipant::handshake_state_, OpenDDS::RTPS::HANDSHAKE_STATE_BEGIN_HANDSHAKE_REPLY, OpenDDS::RTPS::HANDSHAKE_STATE_BEGIN_HANDSHAKE_REQUEST, OpenDDS::RTPS::HANDSHAKE_STATE_DONE, OpenDDS::RTPS::HANDSHAKE_STATE_PROCESS_HANDSHAKE, OpenDDS::RTPS::DiscoveredParticipant::have_auth_req_msg_, OpenDDS::RTPS::DiscoveredParticipant::identity_handle_, identity_handle_, initialized_flag_, OpenDDS::RTPS::DiscoveredParticipant::is_requester_, LM_DEBUG, LM_WARNING, local_participant_data_as_octets(), lock_, OpenDDS::DCPS::make_id(), match_authenticated(), DDS::Security::SecurityException::message, DDS::Security::ParticipantGenericMessage::message_class_id, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, DDS::Security::SecurityException::minor_code, participants_, purge_handshake_deadlines(), DDS::Security::ParticipantGenericMessage::related_message_identity, DDS::RETCODE_OK, security_config_, OpenDDS::DCPS::security_debug, sedp_, send_handshake_message(), DDS::Security::MessageIdentity::sequence_number, set_auth_state(), shutdown_flag_, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, DDS::Security::MessageIdentity::source_guid, DDS::Security::VALIDATION_FAILED, DDS::Security::VALIDATION_OK, DDS::Security::VALIDATION_OK_FINAL_MESSAGE, DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE, DDS::Security::VALIDATION_PENDING_HANDSHAKE_REQUEST, and DDS::Security::VALIDATION_PENDING_RETRY.

Referenced by OpenDDS::RTPS::Sedp::received_stateless_message().

 {
   DDS::Security::SecurityException se = {"", 0, 0};
   Security::Authentication_var auth = security_config_->get_authentication();
 
   const GUID_t src_participant = make_id(msg.message_identity.source_guid, DCPS::ENTITYID_PARTICIPANT);
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                ACE_TEXT("%C -> %C local %C\n"),
                DCPS::LogGuid(src_participant).c_str(),
                DCPS::LogGuid(msg.destination_participant_guid).c_str(),
                DCPS::LogGuid(guid_).c_str()));
   }
 
   // If this message wasn't intended for us, ignore handshake message
   if (msg.destination_participant_guid != guid_) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                  ACE_TEXT("Dropped not recipient\n")));
     }
     return;
   }
 
   if (msg.message_data.length() == 0) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                  ACE_TEXT("Dropped no data\n")));
     }
     return;
   }
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (!initialized_flag_ || shutdown_flag_ ) {
     return;
   }
 
   // If discovery hasn't initialized / validated this participant yet, ignore handshake messages
   DiscoveredParticipantIter iter = participants_.find(src_participant);
   if (iter == participants_.end()) {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING,
         ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_handshake_message() - ")
         ACE_TEXT("received handshake for undiscovered participant %C. Ignoring.\n"),
         DCPS::LogGuid(src_participant).c_str()));
     }
     return;
   }
 
   DiscoveredParticipant& dp = iter->second;
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - "
       "for %C auth_state=%d handshake_state=%d\n",
       DCPS::LogGuid(src_participant).c_str(),
       dp.auth_state_, dp.handshake_state_));
   }
 
   // We have received a handshake message from the remote which means
   // we don't need to send the auth req.
   dp.have_auth_req_msg_ = false;
 
   dp.handshake_resend_falloff_.set(config_->auth_resend_period());
 
   if (dp.handshake_state_ == HANDSHAKE_STATE_DONE && !dp.is_requester_) {
     // Remote is still sending a reply, so resend the final.
     const GUID_t reader = make_id(iter->first, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER);
     if (sedp_->write_stateless_message(dp.handshake_msg_, reader) != DDS::RETCODE_OK) {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Unable to write handshake message.\n")));
       }
     } else {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Sent handshake message for participant: %C\n"),
                    DCPS::LogGuid(iter->first).c_str()));
       }
     }
     return;
   }
 
   if (msg.message_identity.sequence_number <= iter->second.handshake_sequence_number_) {
     return;
   }
   iter->second.handshake_sequence_number_ = msg.message_identity.sequence_number;
 
   switch (dp.handshake_state_) {
   case HANDSHAKE_STATE_DONE:
     // Handled above.
     return;
 
   case HANDSHAKE_STATE_BEGIN_HANDSHAKE_REQUEST: {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING,
                  ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_handshake_message() - ")
                  ACE_TEXT("Invalid handshake state\n")));
     }
     return;
   }
 
   case HANDSHAKE_STATE_BEGIN_HANDSHAKE_REPLY: {
     DDS::Security::ParticipantStatelessMessage reply = DDS::Security::ParticipantStatelessMessage();
     reply.message_identity.source_guid = guid_;
     reply.message_identity.sequence_number = 0;
     reply.message_class_id = DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE;
     reply.related_message_identity = msg.message_identity;
     reply.destination_participant_guid = src_participant;
     reply.destination_endpoint_guid = GUID_UNKNOWN;
     reply.source_endpoint_guid = GUID_UNKNOWN;
     reply.message_data.length(1);
     reply.message_data[0] = msg.message_data[0];
 
     if (dp.handshake_handle_ != DDS::HANDLE_NIL) {
       // Return the handle for reauth.
       if (!auth->return_handshake_handle(dp.handshake_handle_, se)) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                      ACE_TEXT("Spdp::handke_handshake_message() - ")
                      ACE_TEXT("Unable to return handshake handle. ")
                      ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                      se.code, se.minor_code, se.message.in()));
         }
         return;
       }
       dp.handshake_handle_ = DDS::HANDLE_NIL;
     }
 
     const DDS::OctetSeq local_participant = local_participant_data_as_octets();
     if (!local_participant.length()) {
       return; // already logged in local_participant_data_as_octets()
     }
     const DDS::Security::ValidationResult_t vr =
       auth->begin_handshake_reply(dp.handshake_handle_, reply.message_data[0], dp.identity_handle_,
                                   identity_handle_, local_participant, se);
 
     switch (vr) {
     case DDS::Security::VALIDATION_OK: {
       // Theoretically, this shouldn't happen unless handshakes can involve fewer than 3 messages
       set_auth_state(dp, AUTH_STATE_AUTHENTICATED);
       dp.handshake_state_ = HANDSHAKE_STATE_DONE;
       purge_handshake_deadlines(iter);
       match_authenticated(src_participant, iter);
       return;
     }
     case DDS::Security::VALIDATION_FAILED: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Failed to reply to incoming handshake message. Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_RETRY: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Unexpected validation pending retry\n")));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_HANDSHAKE_REQUEST: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Unexpected validation pending handshake request\n")));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE: {
       if (send_handshake_message(src_participant, dp, reply) != DDS::RETCODE_OK) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Unable to write stateless message for handshake reply.\n")));
         }
         return;
       } else {
         if (DCPS::security_debug.auth_debug) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Sent handshake reply for participant: %C\n"),
                      DCPS::LogGuid(src_participant).c_str()));
         }
       }
       dp.handshake_state_ = HANDSHAKE_STATE_PROCESS_HANDSHAKE;
       return;
     }
     case DDS::Security::VALIDATION_OK_FINAL_MESSAGE: {
       // Theoretically, this shouldn't happen unless handshakes can involve fewer than 3 messages
       if (send_handshake_message(src_participant, dp, reply) != DDS::RETCODE_OK) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Unable to write stateless message for final message.\n")));
         }
         return;
       } else {
         if (DCPS::security_debug.auth_debug) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Sent handshake final for participant: %C\n"),
                      DCPS::LogGuid(src_participant).c_str()));
         }
       }
       set_auth_state(dp, AUTH_STATE_AUTHENTICATED);
       dp.handshake_state_ = HANDSHAKE_STATE_PROCESS_HANDSHAKE;
       purge_handshake_deadlines(iter);
       match_authenticated(src_participant, iter);
       return;
     }
     }
     return;
   }
 
   case HANDSHAKE_STATE_PROCESS_HANDSHAKE: {
     DDS::Security::ParticipantStatelessMessage reply = DDS::Security::ParticipantStatelessMessage();
     reply.message_identity.source_guid = guid_;
     reply.message_identity.sequence_number = 0;
     reply.message_class_id = DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE;
     reply.related_message_identity = msg.message_identity;
     reply.destination_participant_guid = src_participant;
     reply.destination_endpoint_guid = GUID_UNKNOWN;
     reply.source_endpoint_guid = GUID_UNKNOWN;
     reply.message_data.length(1);
 
     DDS::Security::ValidationResult_t vr = auth->process_handshake(reply.message_data[0], msg.message_data[0],
                                                                    dp.handshake_handle_, se);
     switch (vr) {
     case DDS::Security::VALIDATION_FAILED: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: ")
                    ACE_TEXT("Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Failed to process incoming handshake message when ")
                    ACE_TEXT("expecting %C from %C. Security Exception[%d.%d]: %C\n"),
                    dp.is_requester_ ? "final" : "reply",
                    DCPS::LogGuid(src_participant).c_str(),
                    se.code, se.minor_code, se.message.in()));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_RETRY: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Unexpected validation pending retry\n")));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_HANDSHAKE_REQUEST: {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                    ACE_TEXT("Unexpected validation pending handshake request\n")));
       }
       return;
     }
     case DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE: {
       // Theoretically, this shouldn't happen unless handshakes can involve more than 3 messages
       if (send_handshake_message(src_participant, dp, reply) != DDS::RETCODE_OK) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Unable to write stateless message for handshake reply.\n")));
         }
         return;
       } else {
         if (DCPS::security_debug.auth_debug) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Sent handshake unknown message for participant: %C\n"),
                      DCPS::LogGuid(src_participant).c_str()));
         }
       }
       return;
     }
     case DDS::Security::VALIDATION_OK_FINAL_MESSAGE: {
       set_auth_state(dp, AUTH_STATE_AUTHENTICATED);
       dp.handshake_state_ = HANDSHAKE_STATE_DONE;
       // Install the shared secret before sending the final so that
       // we are prepared to receive the crypto tokens from the
       // replier.
 
       // Send the final first because match_authenticated takes forever.
       if (send_handshake_message(src_participant, iter->second, reply) != DDS::RETCODE_OK) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} WARNING: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Unable to write stateless message for final message.\n")));
         }
         return;
       } else {
         if (DCPS::security_debug.auth_debug) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::handle_handshake_message() - ")
                      ACE_TEXT("Sent handshake final for participant: %C\n"),
                      DCPS::LogGuid(src_participant).c_str()));
         }
       }
 
       purge_handshake_deadlines(iter);
       match_authenticated(src_participant, iter);
       return;
     }
     case DDS::Security::VALIDATION_OK: {
       set_auth_state(dp, AUTH_STATE_AUTHENTICATED);
       dp.handshake_state_ = HANDSHAKE_STATE_DONE;
       purge_handshake_deadlines(iter);
       match_authenticated(src_participant, iter);
       return;
     }
     }
   }
   }
 }

◆ handle_participant_crypto_tokens()

bool OpenDDS::RTPS::Spdp::handle_participant_crypto_tokens ( const DDS::Security::ParticipantVolatileMessageSecure & msg )

Definition at line 1885 of file Spdp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_GUARD_RETURN, ACE_TEXT(), DDS::Security::SecurityException::code, crypto_handle_, DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::DCPS::ENTITYID_PARTICIPANT, guid_, DDS::HANDLE_NIL, LM_DEBUG, LM_ERROR, LM_WARNING, lock_, OpenDDS::DCPS::log_progress(), OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, DDS::Security::SecurityException::minor_code, participants_, security_config_, OpenDDS::DCPS::security_debug, sedp_, DDS::Security::MessageIdentity::source_guid, and OpenDDS::DCPS::transport_debug.

Referenced by OpenDDS::RTPS::Sedp::received_volatile_message_secure().

 {
   const GUID_t src_participant = make_id(msg.message_identity.source_guid, DCPS::ENTITYID_PARTICIPANT);
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Spdp::handle_participant_crypto_tokens() from %C\n"),
                DCPS::LogGuid(src_participant).c_str()));
   }
 
   DDS::Security::SecurityException se = {"", 0, 0};
   Security::CryptoKeyExchange_var key_exchange = security_config_->get_crypto_key_exchange();
 
   // If this message wasn't intended for us, ignore volatile message
   if (msg.destination_participant_guid != guid_ || !msg.message_data.length()) {
     return false;
   }
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
 
   if (crypto_handle_ == DDS::HANDLE_NIL) {
     // not configured for RTPS Protection, therefore doesn't support participant crypto tokens
     return false;
   }
 
   // If discovery hasn't initialized / validated this participant yet, ignore volatile message
   DiscoveredParticipantIter iter = participants_.find(src_participant);
   if (iter == participants_.end()) {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING,
         ACE_TEXT("(%P|%t) {auth_warn} Spdp::handle_participant_crypto_tokens() - ")
         ACE_TEXT("received tokens for undiscovered participant %C. Ignoring.\n"),
         DCPS::LogGuid(src_participant).c_str()));
     }
     return false;
   }
 
   if (DCPS::transport_debug.log_progress) {
     log_progress("participant crypto token", guid_, src_participant, iter->second.discovered_at_.to_monotonic_time());
   }
 
   const DDS::Security::ParticipantCryptoTokenSeq& inboundTokens =
     reinterpret_cast<const DDS::Security::ParticipantCryptoTokenSeq&>(msg.message_data);
   const DDS::Security::ParticipantCryptoHandle dp_crypto_handle =
     sedp_->get_handle_registry()->get_remote_participant_crypto_handle(iter->first);
 
   if (!key_exchange->set_remote_participant_crypto_tokens(crypto_handle_, dp_crypto_handle, inboundTokens, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::handle_participant_crypto_tokens() - ")
       ACE_TEXT("Unable to set remote participant crypto tokens with crypto key exchange plugin. ")
       ACE_TEXT("Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     return false;
   }
 
   sedp_->process_association_records_i(iter->second);
 
   return true;
 }

◆ handle_participant_data()

void OpenDDS::RTPS::Spdp::handle_participant_data	(	DCPS::MessageId	id,
		const ParticipantData_t &	pdata,
		const DCPS::MonotonicTimePoint &	now,
		const DCPS::SequenceNumber &	seq,
		const ACE_INET_Addr &	from,
		bool	from_sedp
	)

Definition at line 710 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), DDS::Security::ParticipantSecurityAttributes::allow_unauthenticated_participants, attempt_authentication(), OpenDDS::RTPS::AUTH_STATE_AUTHENTICATED, OpenDDS::RTPS::AUTH_STATE_UNAUTHENTICATED, DDS::Security::ParticipantBuiltinTopicDataSecure::base, bit_subscriber_, OpenDDS::DCPS::LogAddr::c_str(), config_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::Security::SPDPdiscoveredParticipantData::ddsParticipantDataSecure, OpenDDS::Security::SPDPdiscoveredParticipantData::discoveredAt, OpenDDS::DCPS::DISPOSE_INSTANCE, OpenDDS::DCPS::DISPOSE_UNREGISTER_INSTANCE, enqueue_location_update_i(), DDS::Security::ParticipantBuiltinTopicData::extended_builtin_endpoints, guid(), guid_, OpenDDS::DCPS::guid_to_bit_key(), OpenDDS::RTPS::ParticipantProxy_t::guidPrefix, DDS::HANDLE_NIL, ice_agent_, DDS::Security::ParticipantBuiltinTopicData::identity_token, initialized_flag_, is_security_enabled(), OpenDDS::Security::SPDPdiscoveredParticipantData::leaseDuration, LM_DEBUG, OpenDDS::RTPS::locators_changed(), lock_, OpenDDS::DCPS::log_progress(), OpenDDS::DCPS::make_part_guid(), match_authenticated(), match_unauthenticated(), n_participants_in_authentication_, DDS::NEW_VIEW_STATE, DDS::NOT_NEW_VIEW_STATE, OpenDDS::RTPS::ParticipantProxy_t::opendds_rtps_relay_application_participant, participant_sec_attr_, OpenDDS::Security::SPDPdiscoveredParticipantData::participantProxy, participants_, DDS::Security::ParticipantBuiltinTopicData::permissions_token, process_location_updates_i(), DDS::Security::ParticipantBuiltinTopicData::property, purge_discovered_participant(), purge_handshake_deadlines(), ACE_Time_Value::sec(), OpenDDS::RTPS::Duration_t::seconds, secure_part_user_data(), OpenDDS::DCPS::security_debug, DDS::Security::ParticipantBuiltinTopicData::security_info, sedp_, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_DIRECT, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_RELAY, set_auth_state(), shutdown_flag_, stop_ice(), OpenDDS::DCPS::TimeDuration::str(), tport_, OpenDDS::DCPS::transport_debug, update_lease_expiration_i(), update_rtps_relay_application_participant_i(), validateSequenceNumber(), OpenDDS::DCPS::TimeDuration::value(), and OpenDDS::DCPS::TimeDuration::zero_value.

Referenced by data_received(), and OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i().

 {
   // Make a (non-const) copy so we can tweak values below
   ParticipantData_t pdata(cpdata);
 
   const GUID_t guid = DCPS::make_part_guid(pdata.participantProxy.guidPrefix);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   if (sedp_->ignoring(guid)) {
     // Ignore, this is our domain participant or one that the user has
     // asked us to ignore.
     return;
   }
 
   const bool relay_in_use = (config_->rtps_relay_only() || config_->use_rtps_relay());
   const bool from_relay = relay_in_use && (from == config_->spdp_rtps_relay_address());
 
 #ifndef DDS_HAS_MINIMUM_BIT
   const DCPS::ParticipantLocation location_mask = compute_location_mask(from, from_relay);
 #endif
 
   // Don't trust SPDP for the RtpsRelay application participant.
   // Otherwise, anyone can reset the application participant.
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled() && !from_sedp) {
     pdata.participantProxy.opendds_rtps_relay_application_participant = false;
   }
 #endif
 
   // Find the participant - iterator valid only as long as we hold the lock
   DiscoveredParticipantIter iter = participants_.find(guid);
 
   if (iter == participants_.end()) {
     // Trying to delete something that doesn't exist is a NOOP
     if (id == DCPS::DISPOSE_INSTANCE || id == DCPS::DISPOSE_UNREGISTER_INSTANCE) {
       return;
     }
 
 #ifdef OPENDDS_SECURITY
     if (config_->max_participants_in_authentication() &&
         n_participants_in_authentication_ >= config_->max_participants_in_authentication()) {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG,
                    "(%P|%t) {auth_debug} DEBUG: Spdp::handle_participant_data - participants_in_authentication: %B >= max: %B\n",
                    n_participants_in_authentication_, config_->max_participants_in_authentication()));
       }
       return;
     }
 #endif
 
     partBitData(pdata).key = guid_to_bit_key(guid);
 
     TimeDuration effective_lease(pdata.leaseDuration.seconds);
 
     if (DCPS::DCPS_debug_level) {
       ACE_DEBUG((LM_DEBUG,
         ACE_TEXT("(%P|%t) Spdp::handle_participant_data - %C discovered %C lease %C from %C (%B)\n"),
         DCPS::LogGuid(guid_).c_str(), DCPS::LogGuid(guid).c_str(),
         effective_lease.str(0).c_str(), DCPS::LogAddr(from).c_str(),
         participants_.size()));
     }
 
     if (!from_sedp) {
 #ifdef OPENDDS_SECURITY
       if (is_security_enabled()) {
         effective_lease = config_->security_unsecure_lease_duration();
       } else {
 #endif
         const TimeDuration maxLeaseDuration = config_->max_lease_duration();
         if (maxLeaseDuration && effective_lease > maxLeaseDuration) {
           if (DCPS::DCPS_debug_level >= 2) {
             ACE_DEBUG((LM_DEBUG,
               ACE_TEXT("(%P|%t) Spdp::handle_participant_data - overwriting %C lease %C from %C with %C\n"),
               DCPS::LogGuid(guid).c_str(), effective_lease.str(0).c_str(),
               DCPS::LogAddr(from).c_str(), maxLeaseDuration.str(0).c_str()));
           }
           effective_lease = maxLeaseDuration;
         }
 #ifdef OPENDDS_SECURITY
       }
 #endif
     }
 
     pdata.leaseDuration.seconds = static_cast<ACE_CDR::Long>(effective_lease.value().sec());
 
     if (tport_->directed_send_task_) {
       if (tport_->directed_guids_.empty()) {
         tport_->directed_send_task_->schedule(TimeDuration::zero_value);
       }
       tport_->directed_guids_.push_back(guid);
     }
 
     // add a new participant
 
 #ifdef OPENDDS_SECURITY
     std::pair<DiscoveredParticipantIter, bool> p = participants_.insert(std::make_pair(guid, DiscoveredParticipant(pdata, seq, config_->auth_resend_period())));
     ++n_participants_in_authentication_;
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG,
                  "(%P|%t) {auth_debug} DEBUG: Spdp::handle_participant_data() %B participants in authentication\n",
                  n_participants_in_authentication_));
     }
 #else
     std::pair<DiscoveredParticipantIter, bool> p = participants_.insert(std::make_pair(guid, DiscoveredParticipant(pdata, seq, TimeDuration())));
 #endif
     iter = p.first;
     iter->second.discovered_at_ = now;
     update_lease_expiration_i(iter, now);
     update_rtps_relay_application_participant_i(iter, p.second);
 
     if (!from_relay && from != ACE_INET_Addr()) {
       iter->second.last_recv_address_ = from;
     }
 
     if (DCPS::transport_debug.log_progress) {
       log_progress("participant discovery", guid_, guid, iter->second.discovered_at_.to_monotonic_time());
     }
 
 #ifndef DDS_HAS_MINIMUM_BIT
     if (!from_sedp) {
       enqueue_location_update_i(iter, location_mask, from, "new participant");
     }
 #endif
 
     sedp_->associate(iter->second
 #ifdef OPENDDS_SECURITY
                      , participant_sec_attr_
 #endif
                      );
 
     // Since we've just seen a new participant, let's send out our
     // own announcement, so they don't have to wait.
     if (from != ACE_INET_Addr()) {
       if (from_relay) {
         tport_->write_i(guid, iter->second.last_recv_address_, SpdpTransport::SEND_RELAY);
       } else {
         tport_->shorten_local_sender_delay_i();
       }
     }
 
 #ifdef OPENDDS_SECURITY
     if (is_security_enabled()) {
       if (!iter->second.has_security_data()) {
         if (!participant_sec_attr_.allow_unauthenticated_participants) {
           if (DCPS::security_debug.auth_debug) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::handle_participant_data - ")
               ACE_TEXT("Incompatible security attributes in discovered participant: %C\n"),
               DCPS::LogGuid(guid).c_str()));
           }
           // FUTURE: This is probably not a good idea since it will just get rediscovered.
           purge_discovered_participant(iter);
           participants_.erase(iter);
           iter = participants_.end();
         } else { // allow_unauthenticated_participants == true
           set_auth_state(iter->second, AUTH_STATE_UNAUTHENTICATED);
           match_unauthenticated(iter);
         }
       } else {
         iter->second.identity_token_ = pdata.ddsParticipantDataSecure.base.identity_token;
         iter->second.permissions_token_ = pdata.ddsParticipantDataSecure.base.permissions_token;
         iter->second.property_qos_ = pdata.ddsParticipantDataSecure.base.property;
         iter->second.security_info_ = pdata.ddsParticipantDataSecure.base.security_info;
         iter->second.extended_builtin_endpoints_ = pdata.ddsParticipantDataSecure.base.extended_builtin_endpoints;
 
         // The remote needs to see our SPDP before attempting authentication.
         tport_->write_i(guid, iter->second.last_recv_address_, from_relay ? SpdpTransport::SEND_RELAY : SpdpTransport::SEND_DIRECT);
 
         attempt_authentication(iter, true);
 
         if (iter->second.auth_state_ == AUTH_STATE_UNAUTHENTICATED) {
           if (!participant_sec_attr_.allow_unauthenticated_participants) {
             if (DCPS::security_debug.auth_debug) {
               ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::handle_participant_data - ")
                 ACE_TEXT("Incompatible security attributes in discovered participant: %C\n"),
                 DCPS::LogGuid(guid).c_str()));
             }
             purge_discovered_participant(iter);
             participants_.erase(iter);
             iter = participants_.end();
           } else { // allow_unauthenticated_participants == true
             set_auth_state(iter->second, AUTH_STATE_UNAUTHENTICATED);
             match_unauthenticated(iter);
           }
         } else if (iter->second.auth_state_ == AUTH_STATE_AUTHENTICATED) {
           if (!match_authenticated(guid, iter)) {
             purge_discovered_participant(iter);
             participants_.erase(iter);
             iter = participants_.end();
           }
         }
         // otherwise just return, since we're waiting for input to finish authentication
       }
     } else {
       set_auth_state(iter->second, AUTH_STATE_UNAUTHENTICATED);
       match_unauthenticated(iter);
     }
 #else
     match_unauthenticated(iter);
 #endif
 
   } else { // Existing Participant
     if (from_sedp && DCPS::transport_debug.log_progress) {
       log_progress("secure participant discovery", guid_, guid, iter->second.discovered_at_.to_monotonic_time());
     }
 
 #ifndef DDS_HAS_MINIMUM_BIT
     if (!from_sedp) {
       enqueue_location_update_i(iter, location_mask, from, "existing participant");
     }
 #endif
 #ifdef OPENDDS_SECURITY
     // Non-secure updates for authenticated participants are used for liveliness but
     // are otherwise ignored. Non-secure dispose messages are ignored completely.
     if (is_security_enabled() && iter->second.auth_state_ == AUTH_STATE_AUTHENTICATED && !from_sedp) {
       update_lease_expiration_i(iter, now);
       if (!from_relay && from != ACE_INET_Addr()) {
         iter->second.last_recv_address_ = from;
       }
 #ifndef DDS_HAS_MINIMUM_BIT
       process_location_updates_i(iter, "non-secure liveliness");
 #endif
       return;
     }
 #endif
 
     if (id == DCPS::DISPOSE_INSTANCE || id == DCPS::DISPOSE_UNREGISTER_INSTANCE) {
 #ifdef OPENDDS_SECURITY
       DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
       if (sedp_endpoint) {
         stop_ice(sedp_endpoint, iter->first, iter->second.pdata_.participantProxy.availableBuiltinEndpoints,
                  iter->second.pdata_.participantProxy.availableExtendedBuiltinEndpoints);
       }
       DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint = tport_->get_ice_endpoint();
       if (spdp_endpoint) {
         ice_agent_->stop_ice(spdp_endpoint, guid_, iter->first);
       }
       purge_handshake_deadlines(iter);
 #endif
 #ifndef DDS_HAS_MINIMUM_BIT
       process_location_updates_i(iter, "dispose/unregister");
 #endif
       if (iter != participants_.end()) {
         purge_discovered_participant(iter);
         participants_.erase(iter);
       }
       return;
     }
 
     // Check if sequence numbers are increasing
     if (validateSequenceNumber(now, seq, iter)) {
       // update an existing participant
       DDS::ParticipantBuiltinTopicData& pdataBit = partBitData(pdata);
       DDS::ParticipantBuiltinTopicData& discoveredBit = partBitData(iter->second.pdata_);
       pdataBit.key = discoveredBit.key;
 
 #ifndef OPENDDS_SAFETY_PROFILE
       using DCPS::operator!=;
 #endif
       if (discoveredBit.user_data != pdataBit.user_data ||
           (from_sedp && iter->second.bit_ih_ == DDS::HANDLE_NIL)) {
         discoveredBit.user_data = pdataBit.user_data;
 
         // If secure user data, this is the first time we should be
         // seeing the real user data.
         iter->second.bit_ih_ = bit_subscriber_->add_participant(pdataBit, secure_part_user_data() ? DDS::NEW_VIEW_STATE : DDS::NOT_NEW_VIEW_STATE);
       }
       if (locators_changed(iter->second.pdata_.participantProxy, pdata.participantProxy)) {
         sedp_->update_locators(pdata);
       }
       const DCPS::MonotonicTime_t da = iter->second.pdata_.discoveredAt;
       iter->second.pdata_ = pdata;
       iter->second.pdata_.discoveredAt = da;
       update_lease_expiration_i(iter, now);
       update_rtps_relay_application_participant_i(iter, false);
       if (!from_relay && from != ACE_INET_Addr()) {
         iter->second.last_recv_address_ = from;
       }
 
 #ifndef DDS_HAS_MINIMUM_BIT
       /*
        * If secure user data, force update location bit because we just gave
        * the first data on the participant. Readers might have been ignoring
        * location samples on the participant until now.
        */
       process_location_updates_i(iter, "valid SPDP", secure_part_user_data());
 #endif
     // Else a reset has occurred and check if we should remove the participant
     } else if (iter->second.seq_reset_count_ >= config_->max_spdp_sequence_msg_reset_check()) {
 #ifdef OPENDDS_SECURITY
       purge_handshake_deadlines(iter);
 #endif
 #ifndef DDS_HAS_MINIMUM_BIT
       process_location_updates_i(iter, "reset");
 #endif
       if (iter != participants_.end()) {
         purge_discovered_participant(iter);
         participants_.erase(iter);
       }
       return;
     }
   }
 
 #ifndef DDS_HAS_MINIMUM_BIT
   if (iter != participants_.end()) {
     process_location_updates_i(iter, "catch all");
   }
 #endif
 }

◆ has_discovered_participant()

bool OpenDDS::RTPS::Spdp::has_discovered_participant ( const DCPS::GUID_t & guid ) const

Definition at line 3688 of file Spdp.cpp.

References participants_.

Referenced by OpenDDS::RTPS::Sedp::data_received(), has_domain_participant(), and OpenDDS::RTPS::Sedp::received_participant_message_data_secure().

 {
   return participants_.find(guid) != participants_.end();
 }

◆ has_domain_participant()

bool OpenDDS::RTPS::Spdp::has_domain_participant ( const GUID_t & ignoreId ) const

Definition at line 4674 of file Spdp.cpp.

References ACE_GUARD_RETURN, has_discovered_participant(), and lock_.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   return has_discovered_participant(remote);
 }

◆ ignore_domain_participant()

void OpenDDS::RTPS::Spdp::ignore_domain_participant ( const GUID_t & ignoreId )

Definition at line 4644 of file Spdp.cpp.

References ACE_GUARD, endpoint_manager(), OpenDDS::RTPS::Sedp::ignore(), lock_, participants_, and purge_discovered_participant().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   endpoint_manager().ignore(ignoreId);
 
   DiscoveredParticipantIter iter = participants_.find(ignoreId);
   if (iter != participants_.end()) {
     purge_discovered_participant(iter);
     participants_.erase(iter);
   }
 }

◆ ignore_publication()

void OpenDDS::RTPS::Spdp::ignore_publication ( const GUID_t & ignoreId )

inline

Definition at line 277 of file Spdp.h.

References ACE_GUARD, and lock_.

   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     return endpoint_manager().ignore(ignoreId);
   }

◆ ignore_subscription()

void OpenDDS::RTPS::Spdp::ignore_subscription ( const GUID_t & ignoreId )

inline

Definition at line 317 of file Spdp.h.

References ACE_GUARD, and lock_.

   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     return endpoint_manager().ignore(ignoreId);
   }

◆ ignore_topic()

void OpenDDS::RTPS::Spdp::ignore_topic ( const GUID_t & ignoreId )

inline

Definition at line 249 of file Spdp.h.

References ACE_GUARD, and lock_.

   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     endpoint_manager().ignore(ignoreId);
   }

◆ init()

void OpenDDS::RTPS::Spdp::init	(	DDS::DomainId_t	domain,
		DCPS::GUID_t &	guid,
		const DDS::DomainParticipantQos &	qos,
		XTypes::TypeLookupService_rch	tls
	)

private

Definition at line 135 of file Spdp.cpp.

References available_builtin_endpoints_, available_extended_builtin_endpoints_, OpenDDS::RTPS::BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER, OpenDDS::RTPS::BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER, OpenDDS::RTPS::BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER, OpenDDS::RTPS::BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER, OpenDDS::RTPS::BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER, OpenDDS::RTPS::BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER, DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER, DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER, DDS::Security::BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER, DDS::Security::BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER, DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER, DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER, config_, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PARTICIPANT_ANNOUNCER, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PARTICIPANT_DETECTOR, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR, guid_, is_application_participant_, is_security_enabled(), DDS::Property_t::name, OpenDDS::RTPS::PFLAGS_REFLECT_HEARTBEAT_COUNT, DDS::DomainParticipantQos::property, OpenDDS::RTPS::RTPS_DISCOVERY_ENDPOINT_ANNOUNCEMENTS, OpenDDS::RTPS::RTPS_DISCOVERY_TYPE_LOOKUP_SERVICE, OpenDDS::RTPS::RTPS_REFLECT_HEARTBEAT_COUNT, OpenDDS::RTPS::RTPS_RELAY_APPLICATION_PARTICIPANT, sedp_, DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_READER, DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER, DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER, DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER, DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_READER, DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER, type_lookup_service_, DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE, DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE, DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE, DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE, and DDS::PropertyQosPolicy::value.

Referenced by Spdp().

 {
   type_lookup_service_ = tls;
 
   bool enable_endpoint_announcements = true;
   bool enable_type_lookup_service = config_->use_xtypes();
 
   const DDS::PropertySeq& properties = qos.property.value;
   for (unsigned int idx = 0; idx != properties.length(); ++idx) {
     const DDS::Property_t& prop = properties[idx];
     if (std::strcmp(RTPS_DISCOVERY_ENDPOINT_ANNOUNCEMENTS, prop.name.in()) == 0) {
       enable_endpoint_announcements = prop_to_bool(prop);
     } else if (std::strcmp(RTPS_DISCOVERY_TYPE_LOOKUP_SERVICE, prop.name.in()) == 0) {
       enable_type_lookup_service = prop_to_bool(prop);
     } else if (std::strcmp(RTPS_RELAY_APPLICATION_PARTICIPANT, prop.name.in()) == 0) {
       is_application_participant_ = prop_to_bool(prop);
     } else if (std::strcmp(RTPS_REFLECT_HEARTBEAT_COUNT, prop.name.in()) == 0) {
       const CORBA::ULong old_flags = config_->participant_flags();
       const CORBA::ULong new_flags = prop_to_bool(prop) ? (old_flags | PFLAGS_REFLECT_HEARTBEAT_COUNT) : (old_flags & ~PFLAGS_REFLECT_HEARTBEAT_COUNT);
       config_->participant_flags(new_flags);
     }
   }
 
   available_builtin_endpoints_ =
     DISC_BUILTIN_ENDPOINT_PARTICIPANT_ANNOUNCER |
     DISC_BUILTIN_ENDPOINT_PARTICIPANT_DETECTOR |
     DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR |
     DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR |
     BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER;
 
   if (enable_endpoint_announcements) {
     available_builtin_endpoints_ |=
       DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER |
       DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER |
       BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER;
   }
 
   if (enable_type_lookup_service) {
     available_builtin_endpoints_ |=
       BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER |
       BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER |
       BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER |
       BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER;
   }
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled()) {
     using namespace DDS::Security;
 
     available_builtin_endpoints_ |=
       SEDP_BUILTIN_PUBLICATIONS_SECURE_READER |
       SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER |
       BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER |
       BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER |
       BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER |
       BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER |
       BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER |
       SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER |
       SPDP_BUILTIN_PARTICIPANT_SECURE_READER;
 
     if (enable_endpoint_announcements) {
       available_builtin_endpoints_ |=
         SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER |
         SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER |
         BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     }
 
     if (enable_type_lookup_service) {
       available_extended_builtin_endpoints_ =
         TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE |
         TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE |
         TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE |
         TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE;
     }
   }
 #endif
 
   guid = guid_; // may have changed in SpdpTransport constructor
   sedp_->ignore(guid);
 }

◆ init_bit()

void OpenDDS::RTPS::Spdp::init_bit ( RcHandle< DCPS::BitSubscriber > bit_subscriber )

Definition at line 2155 of file Spdp.cpp.

References bit_subscriber_, disco_, domain_, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, guid_, ice_agent_, initialized_flag_, OpenDDS::DCPS::make_id(), OPENDDS_ASSERT, OpenDDS::DCPS::rchandle_from(), sedp_, tport_, and type_lookup_service_.

 {
   OPENDDS_ASSERT(bit_subscriber);
 
   bit_subscriber_ = bit_subscriber;
 
   // Defer initilization until we have the bit subscriber.
   sedp_->init(guid_, *disco_, domain_, type_lookup_service_);
   tport_->open(sedp_->reactor_task(), sedp_->job_queue());
 
 #ifdef OPENDDS_SECURITY
   DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
   if (sedp_endpoint) {
     const GUID_t l = make_id(guid_, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER);
     ice_agent_->add_local_agent_info_listener(sedp_endpoint, l, DCPS::static_rchandle_cast<AgentInfoListener>(rchandle_from(this)));
   }
 #endif
 
   initialized_flag_ = true;
   tport_->enable_periodic_tasks();
 }

◆ initialized()

bool OpenDDS::RTPS::Spdp::initialized ( void )

inline

Definition at line 110 of file Spdp.h.

References shutdown().

Referenced by OpenDDS::RTPS::Sedp::data_received().

   {
     return initialized_flag_;
   }

◆ is_expectant_opendds()

bool OpenDDS::RTPS::Spdp::is_expectant_opendds ( const GUID_t & participant ) const

Definition at line 2191 of file Spdp.cpp.

References participants_, and OpenDDS::RTPS::PFLAGS_NO_ASSOCIATED_WRITERS.

Referenced by OpenDDS::RTPS::Sedp::is_expectant_opendds().

 {
   const DiscoveredParticipantConstIter iter = participants_.find(participant);
   if (iter == participants_.end()) {
     return false;
   }
   return is_opendds(iter->second.pdata_.participantProxy) &&
     (iter->second.pdata_.participantProxy.opendds_participant_flags.bits & PFLAGS_NO_ASSOCIATED_WRITERS) == 0;
 }

◆ is_security_enabled()

bool OpenDDS::RTPS::Spdp::is_security_enabled ( ) const

inline

Definition at line 159 of file Spdp.h.

Referenced by announce_domain_participant_qos(), OpenDDS::RTPS::Sedp::associate(), data_received(), OpenDDS::RTPS::Sedp::disassociate(), handle_participant_data(), init(), OpenDDS::RTPS::Sedp::remote_is_authenticated_i(), remove_agent_info(), update_agent_info(), and use_ice_now().

159 { return security_enabled_; }

OpenDDS::RTPS::Spdp::security_enabled_

bool security_enabled_

Definition: Spdp.h:619

◆ local_participant_data_as_octets()

DDS::OctetSeq OpenDDS::RTPS::Spdp::local_participant_data_as_octets ( ) const

Definition at line 1217 of file Spdp.cpp.

Referenced by handle_handshake_message(), and send_handshake_request().

 {
   DDS::Security::ParticipantBuiltinTopicDataSecure pbtds = {
     {
       get_part_bit_data(false),
       identity_token_,
       permissions_token_,
       qos_.property,
       {0, 0},
       0
     },
     identity_status_token_
   };
 
   pbtds.base.security_info.plugin_participant_security_attributes = participant_sec_attr_.plugin_participant_attributes;
   pbtds.base.security_info.participant_security_attributes = DDS::Security::PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_VALID;
   if (participant_sec_attr_.is_rtps_protected) {
     pbtds.base.security_info.participant_security_attributes |= DDS::Security::PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_RTPS_PROTECTED;
   }
   if (participant_sec_attr_.is_discovery_protected) {
     pbtds.base.security_info.participant_security_attributes |= DDS::Security::PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_DISCOVERY_PROTECTED;
     pbtds.base.extended_builtin_endpoints =
       DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE | DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE |
       DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE | DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE;
   }
   if (participant_sec_attr_.is_liveliness_protected) {
     pbtds.base.security_info.participant_security_attributes |= DDS::Security::PARTICIPANT_SECURITY_ATTRIBUTES_FLAG_IS_LIVELINESS_PROTECTED;
   }
 
   ParameterList plist;
   set_participant_guid(guid_, plist);
 
   if (!ParameterListConverter::to_param_list(pbtds.base, plist)) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::local_participant_data_as_octets() - ")
                 ACE_TEXT("Failed to convert from ParticipantBuiltinTopicData to ParameterList\n")));
     }
     return DDS::OctetSeq();
   }
 
   ACE_Message_Block temp_buff(DCPS::serialized_size(encoding_plain_big, plist));
   DCPS::Serializer ser(&temp_buff, encoding_plain_big);
   if (!(ser << plist)) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::local_participant_data_as_octets() - ")
                 ACE_TEXT("Failed to serialize parameter list.\n")));
     }
     return DDS::OctetSeq();
   }
 
   DDS::OctetSeq seq(static_cast<unsigned int>(temp_buff.length()));
   seq.length(seq.maximum());
   std::memcpy(seq.get_buffer(), temp_buff.rd_ptr(), temp_buff.length());
   return seq;
 }

◆ lookup_participant_auth_state()

AuthState OpenDDS::RTPS::Spdp::lookup_participant_auth_state ( const GUID_t & id ) const

Definition at line 3855 of file Spdp.cpp.

References OpenDDS::RTPS::AUTH_STATE_HANDSHAKE, lock_, and participants_.

Referenced by OpenDDS::RTPS::Sedp::process_discovered_reader_data(), and OpenDDS::RTPS::Sedp::process_discovered_writer_data().

 {
   ACE_Guard<ACE_Thread_Mutex> g(lock_, false);
   DiscoveredParticipantConstIter pi = participants_.find(id);
   if (pi != participants_.end()) {
     return pi->second.auth_state_;
   }
   return AUTH_STATE_HANDSHAKE;
 }

◆ lookup_participant_crypto_info()

Spdp::ParticipantCryptoInfoPair OpenDDS::RTPS::Spdp::lookup_participant_crypto_info ( const DCPS::GUID_t & id ) const

Definition at line 3788 of file Spdp.cpp.

References DDS::HANDLE_NIL, participants_, and sedp_.

Referenced by OpenDDS::RTPS::Sedp::generate_remote_matched_reader_crypto_handle(), and OpenDDS::RTPS::Sedp::generate_remote_matched_writer_crypto_handle().

 {
   ParticipantCryptoInfoPair result = ParticipantCryptoInfoPair(DDS::HANDLE_NIL, DDS::Security::SharedSecretHandle_var());
 
   DiscoveredParticipantConstIter pi = participants_.find(id);
   if (pi != participants_.end()) {
     result.first = sedp_->get_handle_registry()->get_remote_participant_crypto_handle(id);
     result.second = pi->second.shared_secret_handle_;
   }
   return result;
 }

◆ lookup_participant_permissions()

DDS::Security::PermissionsHandle OpenDDS::RTPS::Spdp::lookup_participant_permissions ( const DCPS::GUID_t & id ) const

Definition at line 3843 of file Spdp.cpp.

References DDS::HANDLE_NIL, lock_, and participants_.

Referenced by OpenDDS::RTPS::Sedp::process_discovered_reader_data(), and OpenDDS::RTPS::Sedp::process_discovered_writer_data().

 {
   DDS::Security::PermissionsHandle result = DDS::HANDLE_NIL;
 
   ACE_Guard<ACE_Thread_Mutex> g(lock_, false);
   DiscoveredParticipantConstIter pi = participants_.find(id);
   if (pi != participants_.end()) {
     result = pi->second.permissions_handle_;
   }
   return result;
 }

◆ match_authenticated()

bool OpenDDS::RTPS::Spdp::match_authenticated	(	const DCPS::GUID_t &	guid,
		DiscoveredParticipantIter &	iter
	)

private

Definition at line 1971 of file Spdp.cpp.

References access(), ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, crypto_handle_, domain_, guid_, DDS::HANDLE_NIL, identity_handle_, DDS::Security::ParticipantSecurityAttributes::is_access_protected, LM_DEBUG, LM_WARNING, OpenDDS::DCPS::log_progress(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, participant_sec_attr_, process_location_updates_i(), security_config_, OpenDDS::DCPS::security_debug, sedp_, and OpenDDS::DCPS::transport_debug.

Referenced by handle_handshake_message(), and handle_participant_data().

 {
   if (iter->second.handshake_handle_ == DDS::HANDLE_NIL) {
     return true;
   }
 
   DDS::Security::SecurityException se = {"", 0, 0};
 
   Security::Authentication_var auth = security_config_->get_authentication();
   Security::AccessControl_var access = security_config_->get_access_control();
   Security::CryptoKeyFactory_var key_factory = security_config_->get_crypto_key_factory();
   Security::CryptoKeyExchange_var key_exchange = security_config_->get_crypto_key_exchange();
   Security::HandleRegistry_rch handle_registry = security_config_->get_handle_registry(guid_);
 
   if (iter->second.shared_secret_handle_ != 0) {
     // Return the shared secret.
     if (!auth->return_sharedsecret_handle(iter->second.shared_secret_handle_, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                    ACE_TEXT("Spdp::match_authenticated() - ")
                    ACE_TEXT("Unable to return shared secret handle. Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
 
     // Get the new shared secret.
     iter->second.shared_secret_handle_ = auth->get_shared_secret(iter->second.handshake_handle_, se);
     if (iter->second.shared_secret_handle_ == 0) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                    ACE_TEXT("Spdp::match_authenticated() - ")
                    ACE_TEXT("Unable to get shared secret handle. Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
 
     sedp_->disassociate_volatile(iter->second);
     sedp_->cleanup_volatile_crypto(iter->first);
     sedp_->associate_volatile(iter->second);
     sedp_->generate_remote_matched_crypto_handles(iter->second);
     sedp_->process_association_records_i(iter->second);
 
     if (!auth->return_handshake_handle(iter->second.handshake_handle_, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                    ACE_TEXT("Spdp::send_handshake_request() - ")
                    ACE_TEXT("Unable to return handshake handle. ")
                    ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
 
     iter->second.handshake_handle_ = DDS::HANDLE_NIL;
     return true;
   }
 
   iter->second.shared_secret_handle_ = auth->get_shared_secret(iter->second.handshake_handle_, se);
   if (iter->second.shared_secret_handle_ == 0) {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
         ACE_TEXT("Spdp::match_authenticated() - ")
         ACE_TEXT("Unable to get shared secret handle. Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     }
     return false;
   }
 
   if (!auth->get_authenticated_peer_credential_token(
       iter->second.authenticated_peer_credential_token_, iter->second.handshake_handle_, se)) {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
         ACE_TEXT("Spdp::match_authenticated() - ")
         ACE_TEXT("Unable to get authenticated peer credential token. ")
         ACE_TEXT("Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     }
     return false;
   }
 
   iter->second.permissions_handle_ = access->validate_remote_permissions(
     auth, identity_handle_, iter->second.identity_handle_,
     iter->second.permissions_token_, iter->second.authenticated_peer_credential_token_, se);
   handle_registry->insert_remote_participant_permissions_handle(guid, iter->second.permissions_handle_);
 
   if (participant_sec_attr_.is_access_protected &&
       iter->second.permissions_handle_ == DDS::HANDLE_NIL) {
     if (DCPS::security_debug.auth_warn) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
         ACE_TEXT("Spdp::match_authenticated() - ")
         ACE_TEXT("Unable to validate remote participant with access control plugin. ")
         ACE_TEXT("Security Exception[%d.%d]: %C\n"),
         se.code, se.minor_code, se.message.in()));
     }
     return false;
   }
 
   if (participant_sec_attr_.is_access_protected) {
     if (!access->check_remote_participant(iter->second.permissions_handle_, domain_,
         iter->second.pdata_.ddsParticipantDataSecure, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
           ACE_TEXT("Spdp::match_authenticated() - ")
           ACE_TEXT("Remote participant check failed. Security Exception[%d.%d]: %C\n"),
             se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
   }
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::match_authenticated - ")
                ACE_TEXT("auth and access control complete for peer %C\n"),
                DCPS::LogGuid(guid).c_str()));
   }
 
   if (DCPS::transport_debug.log_progress) {
     log_progress("authentication", guid_, guid, iter->second.discovered_at_.to_monotonic_time());
   }
 
   DDS::Security::ParticipantCryptoHandle dp_crypto_handle =
     sedp_->get_handle_registry()->get_remote_participant_crypto_handle(iter->first);
 
   if (dp_crypto_handle == DDS::HANDLE_NIL) {
     dp_crypto_handle = key_factory->register_matched_remote_participant(
       crypto_handle_, iter->second.identity_handle_, iter->second.permissions_handle_,
       iter->second.shared_secret_handle_, se);
     sedp_->get_handle_registry()->insert_remote_participant_crypto_handle(iter->first, dp_crypto_handle);
     if (dp_crypto_handle == DDS::HANDLE_NIL) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
           ACE_TEXT("Spdp::match_authenticated() - Unable to register remote ")
           ACE_TEXT("participant with crypto key factory plugin. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"),
           se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
   }
 
   if (crypto_handle_ != DDS::HANDLE_NIL) {
     if (!key_exchange->create_local_participant_crypto_tokens(
         iter->second.crypto_tokens_, crypto_handle_, dp_crypto_handle, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_debug} ")
           ACE_TEXT("Spdp::match_authenticated() - ")
           ACE_TEXT("Unable to create local participant crypto ")
           ACE_TEXT("tokens with crypto key exchange plugin. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"),
           se.code, se.minor_code, se.message.in()));
       }
       return false;
     }
   }
 
   sedp_->generate_remote_matched_crypto_handles(iter->second);
 
   // Auth is now complete.
   sedp_->process_association_records_i(iter->second);
 
 #ifndef DDS_HAS_MINIMUM_BIT
   process_location_updates_i(iter, "match_authenticated");
 #endif
   return true;
 }

◆ match_unauthenticated()

void OpenDDS::RTPS::Spdp::match_unauthenticated ( const DiscoveredParticipantIter & dp_iter )

private

Definition at line 1126 of file Spdp.cpp.

References bit_subscriber_, DDS::NEW_VIEW_STATE, process_location_updates_i(), and secure_part_user_data().

Referenced by handle_participant_data(), and process_handshake_deadlines().

 {
 #ifndef DDS_HAS_MINIMUM_BIT
   if (!secure_part_user_data()) { // else the user data is assumed to be blank
     dp_iter->second.bit_ih_ = bit_subscriber_->add_participant(partBitData(dp_iter->second.pdata_), DDS::NEW_VIEW_STATE);
   }
 
   process_location_updates_i(dp_iter, "match_unauthenticated");
 #else
   ACE_UNUSED_ARG(dp_iter);
 #endif /* DDS_HAS_MINIMUM_BIT */
 }

◆ OPENDDS_MAP_CMP() [1/2]

typedef OpenDDS::RTPS::Spdp::OPENDDS_MAP_CMP	(	GUID_t	,
		DiscoveredParticipant	,
		GUID_tKeyLessThan
	)

◆ OPENDDS_MAP_CMP() [2/2]

typedef OpenDDS::RTPS::Spdp::OPENDDS_MAP_CMP	(	GUID_t	,
		DDS::Security::AuthRequestMessageToken	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MULTIMAP()

typedef OpenDDS::RTPS::Spdp::OPENDDS_MULTIMAP	(	DCPS::MonotonicTimePoint	,
		DCPS::GUID_t
	)

private

◆ process_handshake_deadlines()

void OpenDDS::RTPS::Spdp::process_handshake_deadlines ( const DCPS::MonotonicTimePoint & tv )

Definition at line 1758 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), DDS::Security::ParticipantSecurityAttributes::allow_unauthenticated_participants, OpenDDS::RTPS::AUTH_STATE_UNAUTHENTICATED, OpenDDS::DCPS::LogGuid::c_str(), guid_, handshake_deadlines_, OpenDDS::RTPS::HANDSHAKE_STATE_DONE, ice_agent_, initialized_flag_, LM_DEBUG, lock_, match_unauthenticated(), participant_sec_attr_, participants_, purge_discovered_participant(), purge_handshake_resends(), OpenDDS::DCPS::security_debug, sedp_, set_auth_state(), shutdown_flag_, stop_ice(), and tport_.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   for (TimeQueue::iterator pos = handshake_deadlines_.begin(),
         limit = handshake_deadlines_.upper_bound(now); pos != limit;) {
 
     DiscoveredParticipantIter pit = participants_.find(pos->second);
     if (pit != participants_.end()) {
       if (DCPS::security_debug.auth_debug) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::process_handshake_deadlines() - ")
                    ACE_TEXT("Removing discovered participant due to authentication timeout: %C\n"),
                    DCPS::LogGuid(pos->second).c_str()));
       }
       const DCPS::MonotonicTimePoint ptime = pos->first;
       if (!participant_sec_attr_.allow_unauthenticated_participants) {
         DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
         if (sedp_endpoint) {
           stop_ice(sedp_endpoint, pit->first, pit->second.pdata_.participantProxy.availableBuiltinEndpoints,
                    pit->second.pdata_.participantProxy.availableExtendedBuiltinEndpoints);
         }
         DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint = tport_->get_ice_endpoint();
         if (spdp_endpoint) {
           ice_agent_->stop_ice(spdp_endpoint, guid_, pit->first);
         }
         handshake_deadlines_.erase(pos);
         purge_discovered_participant(pit);
         participants_.erase(pit);
       } else {
         purge_handshake_resends(pit);
         set_auth_state(pit->second, AUTH_STATE_UNAUTHENTICATED);
         pit->second.handshake_state_ = HANDSHAKE_STATE_DONE;
         handshake_deadlines_.erase(pos);
         match_unauthenticated(pit);
       }
       pos = handshake_deadlines_.lower_bound(ptime);
       limit = handshake_deadlines_.upper_bound(now);
     } else {
       handshake_deadlines_.erase(pos++);
     }
   }
 
   if (!handshake_deadlines_.empty()) {
     tport_->handshake_deadline_task_->schedule(handshake_deadlines_.begin()->first - now);
   }
 }

◆ process_handshake_resends()

void OpenDDS::RTPS::Spdp::process_handshake_resends ( const DCPS::MonotonicTimePoint & tv )

Definition at line 1810 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), config_, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER, guid_, handshake_resends_, initialized_flag_, LM_DEBUG, lock_, OpenDDS::DCPS::make_id(), participants_, DDS::RETCODE_OK, OpenDDS::DCPS::security_debug, sedp_, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_DIRECT, OpenDDS::RTPS::Spdp::SpdpTransport::SEND_RELAY, shutdown_flag_, and tport_.

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   bool processor_needs_cancel = false;
   for (TimeQueue::iterator pos = handshake_resends_.begin(), limit = handshake_resends_.end();
        pos != limit && pos->first <= now;) {
 
     DiscoveredParticipantIter pit = participants_.find(pos->second);
     if (pit != participants_.end() &&
         pit->second.stateless_msg_deadline_ <= now) {
       const GUID_t reader = make_id(pit->first, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER);
       pit->second.stateless_msg_deadline_ = now + pit->second.handshake_resend_falloff_.get();
 
       // Send the auth req first to reset the remote if necessary.
       if (pit->second.have_auth_req_msg_) {
         // Send the SPDP announcement in case it got lost.
         tport_->write_i(pit->first, pit->second.last_recv_address_, SpdpTransport::SEND_RELAY | SpdpTransport::SEND_DIRECT);
         if (sedp_->transport_inst()->count_messages()) {
           ++tport_->transport_statistics_.writer_resend_count[make_id(guid_, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER)];
         }
         if (sedp_->write_stateless_message(pit->second.auth_req_msg_, reader) != DDS::RETCODE_OK) {
           if (DCPS::security_debug.auth_debug) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::process_handshake_resends() - ")
                        ACE_TEXT("Unable to write auth req message retry.\n")));
           }
         } else {
           if (DCPS::security_debug.auth_debug) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::process_handshake_resends() - ")
                        ACE_TEXT("Sent auth req message for participant: %C\n"),
                        DCPS::LogGuid(pit->first).c_str()));
           }
         }
       }
       if (pit->second.have_handshake_msg_) {
         if (sedp_->transport_inst()->count_messages()) {
           ++tport_->transport_statistics_.writer_resend_count[make_id(guid_, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER)];
         }
         if (sedp_->write_stateless_message(pit->second.handshake_msg_, reader) != DDS::RETCODE_OK) {
           if (DCPS::security_debug.auth_debug) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} Spdp::process_handshake_resends() - ")
                        ACE_TEXT("Unable to write handshake message retry.\n")));
           }
         } else {
           if (DCPS::security_debug.auth_debug) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::process_handshake_resends() - ")
                        ACE_TEXT("Sent handshake message for participant: %C\n"),
                        DCPS::LogGuid(pit->first).c_str()));
           }
         }
       }
       pit->second.handshake_resend_falloff_.advance(config_->max_auth_time());
 
       handshake_resends_.insert(std::make_pair(pit->second.stateless_msg_deadline_, pit->first));
       if (pit->second.stateless_msg_deadline_ < handshake_resends_.begin()->first) {
         processor_needs_cancel = true;
       }
     }
 
     handshake_resends_.erase(pos++);
   }
 
   if (!handshake_resends_.empty()) {
     if (processor_needs_cancel) {
       tport_->handshake_resend_task_->cancel();
     }
     tport_->handshake_resend_task_->schedule(handshake_resends_.begin()->first - now);
   }
 }

◆ process_lease_expirations()

void OpenDDS::RTPS::Spdp::process_lease_expirations ( const DCPS::MonotonicTimePoint & now )

private

Definition at line 3744 of file Spdp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::DCPS_debug_level, guid_, ice_agent_, lease_expirations_, LM_WARNING, lock_, participants_, purge_discovered_participant(), purge_handshake_deadlines(), sedp_, stop_ice(), and tport_.

 {
   ACE_GUARD (ACE_Thread_Mutex, g, lock_);
 
   for (TimeQueue::iterator pos = lease_expirations_.begin(), limit = lease_expirations_.end();
        pos != limit && pos->first <= now;) {
     DiscoveredParticipantIter part = participants_.find(pos->second);
     // Pre-emptively erase so purge_discovered_participant will not modify lease_expirations_.
     lease_expirations_.erase(pos++);
 
     if (part == participants_.end()) {
       continue;
     }
 
     if (DCPS::DCPS_debug_level) {
       ACE_DEBUG((LM_WARNING,
                  ACE_TEXT("(%P|%t) Spdp::process_lease_expirations() - ")
                  ACE_TEXT("participant %C exceeded lease duration, removing\n"),
                  DCPS::LogGuid(part->first).c_str()));
     }
 
 #ifdef OPENDDS_SECURITY
     DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
     if (sedp_endpoint) {
       stop_ice(sedp_endpoint, part->first, part->second.pdata_.participantProxy.availableBuiltinEndpoints,
                part->second.pdata_.participantProxy.availableExtendedBuiltinEndpoints);
     }
     DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint = tport_->get_ice_endpoint();
     if (spdp_endpoint) {
       ice_agent_->stop_ice(spdp_endpoint, guid_, part->first);
     }
     purge_handshake_deadlines(part);
 #endif
     purge_discovered_participant(part);
     participants_.erase(part);
   }
 
   if (!lease_expirations_.empty()) {
     tport_->lease_expiration_task_->schedule(lease_expirations_.begin()->first - now);
   }
 }

◆ process_location_updates_i()

void OpenDDS::RTPS::Spdp::process_location_updates_i	(	const DiscoveredParticipantIter &	iter,
		const char *	reason,
		bool	force_publish = `false`
	)

protected

Definition at line 474 of file Spdp.cpp.

Referenced by handle_participant_data(), match_authenticated(), match_unauthenticated(), process_participant_ice(), rtps_relay_only_now(), use_ice_now(), and use_rtps_relay_now().

 {
   // We have the global lock.
 
   if (iter == participants_.end()) {
     if (DCPS::log_bits) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ iterator invalid, returning\n", this));
     }
     return;
   }
 
   if (iter->second.bit_ih_ == DDS::HANDLE_NIL) {
     // Do not process updates until the participant exists in the built-in topics.
     if (DCPS::log_bits) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ %C does not exist in participant bit, returning\n", this, LogGuid(iter->first).c_str()));
     }
     return;
   }
 
   DiscoveredParticipant::LocationUpdateList location_updates;
   std::swap(iter->second.location_updates_, location_updates);
 
   if (DCPS::log_bits) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ %C has %B location update(s) force_publish=%d reason=%C\n", this, LogGuid(iter->first).c_str(), location_updates.size(), force_publish, reason));
   }
 
   bool published = false;
   for (DiscoveredParticipant::LocationUpdateList::const_iterator pos = location_updates.begin(),
          limit = location_updates.end(); iter != participants_.end() && pos != limit; ++pos) {
     DCPS::ParticipantLocationBuiltinTopicData& location_data = iter->second.location_data_;
 
     OPENDDS_STRING addr = "";
     const DCPS::ParticipantLocation old_mask = location_data.location;
     if (pos->from_ != ACE_INET_Addr()) {
       location_data.location |= pos->mask_;
       addr = DCPS::LogAddr(pos->from_).str();
     } else {
       location_data.location &= ~(pos->mask_);
     }
 
     location_data.change_mask = pos->mask_;
 
     bool address_change = false;
     switch (pos->mask_) {
     case DCPS::LOCATION_LOCAL:
       address_change = addr.compare(location_data.local_addr.in()) != 0;
       location_data.local_addr = addr.c_str();
       location_data.local_timestamp = pos->timestamp_.to_dds_time();
       break;
     case DCPS::LOCATION_ICE:
       address_change = addr.compare(location_data.ice_addr.in()) != 0;
       location_data.ice_addr = addr.c_str();
       location_data.ice_timestamp = pos->timestamp_.to_dds_time();
       break;
     case DCPS::LOCATION_RELAY:
       address_change = addr.compare(location_data.relay_addr.in()) != 0;
       location_data.relay_addr = addr.c_str();
       location_data.relay_timestamp = pos->timestamp_.to_dds_time();
       break;
     case DCPS::LOCATION_LOCAL6:
       address_change = addr.compare(location_data.local6_addr.in()) != 0;
       location_data.local6_addr = addr.c_str();
       location_data.local6_timestamp = pos->timestamp_.to_dds_time();
       break;
     case DCPS::LOCATION_ICE6:
       address_change = addr.compare(location_data.ice6_addr.in()) != 0;
       location_data.ice6_addr = addr.c_str();
       location_data.ice6_timestamp = pos->timestamp_.to_dds_time();
       break;
     case DCPS::LOCATION_RELAY6:
       address_change = addr.compare(location_data.relay6_addr.in()) != 0;
       location_data.relay6_addr = addr.c_str();
       location_data.relay6_timestamp = pos->timestamp_.to_dds_time();
       break;
     }
 
     const DDS::Time_t expr =
       (
        pos->timestamp_ - rtps_duration_to_time_duration(iter->second.pdata_.leaseDuration,
                                                         iter->second.pdata_.participantProxy.protocolVersion,
                                                         iter->second.pdata_.participantProxy.vendorId)
        ).to_dds_time();
     if ((location_data.location & DCPS::LOCATION_LOCAL) && DCPS::operator<(location_data.local_timestamp, expr)) {
       location_data.location &= ~(DCPS::LOCATION_LOCAL);
       location_data.change_mask |= DCPS::LOCATION_LOCAL;
       location_data.local_timestamp = pos->timestamp_.to_dds_time();
     }
     if ((location_data.location & DCPS::LOCATION_RELAY) && DCPS::operator<(location_data.relay_timestamp, expr)) {
       location_data.location &= ~(DCPS::LOCATION_RELAY);
       location_data.change_mask |= DCPS::LOCATION_RELAY;
       location_data.relay_timestamp = pos->timestamp_.to_dds_time();
     }
     if ((location_data.location & DCPS::LOCATION_LOCAL6) && DCPS::operator<(location_data.local6_timestamp, expr)) {
       location_data.location &= ~(DCPS::LOCATION_LOCAL6);
       location_data.change_mask |= DCPS::LOCATION_LOCAL6;
       location_data.local6_timestamp = pos->timestamp_.to_dds_time();
     }
     if ((location_data.location & DCPS::LOCATION_RELAY6) && DCPS::operator<(location_data.relay6_timestamp, expr)) {
       location_data.location &= ~(DCPS::LOCATION_RELAY6);
       location_data.change_mask |= DCPS::LOCATION_RELAY6;
       location_data.relay6_timestamp = pos->timestamp_.to_dds_time();
     }
 
     if (old_mask != location_data.location || address_change) {
       if (DCPS::log_bits) {
         ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ publishing %C update\n", this, LogGuid(iter->first).c_str()));
       }
       publish_location_update_i(iter);
       published = true;
     }
   }
 
   if (force_publish && !published) {
     if (DCPS::log_bits) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ publishing %C forced\n", this, LogGuid(iter->first).c_str()));
     }
     publish_location_update_i(iter);
     published = true;
   }
 
   if (!published && DCPS::log_bits) {
     if (DCPS::log_bits) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::process_location_updates_i: %@ not published\n", this, LogGuid(iter->first).c_str()));
     }
   }
 }

◆ process_participant_ice()

void OpenDDS::RTPS::Spdp::process_participant_ice	(	const ParameterList &	plist,
		const ParticipantData_t &	pdata,
		const DCPS::GUID_t &	guid
	)

Definition at line 4373 of file Spdp.cpp.

References ACE_ERROR, ACE_GUARD, ACE_TEXT(), OpenDDS::RTPS::ParticipantProxy_t::availableBuiltinEndpoints, OpenDDS::RTPS::ParticipantProxy_t::availableExtendedBuiltinEndpoints, OpenDDS::DCPS::DCPS_debug_level, enqueue_location_update_i(), OpenDDS::RTPS::ParameterListConverter::from_param_list(), guid_, ice_agent_, initialized_flag_, LM_ERROR, OpenDDS::DCPS::LOCATION_ICE, lock_, OpenDDS::Security::SPDPdiscoveredParticipantData::participantProxy, participants_, process_location_updates_i(), sedp_, OpenDDS::RTPS::SEDP_AGENT_INFO_KEY, shutdown_flag_, OpenDDS::RTPS::SPDP_AGENT_INFO_KEY, start_ice(), stop_ice(), and tport_.

Referenced by data_received(), and OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i().

 {
   ICE::AgentInfoMap ai_map;
   if (!ParameterListConverter::from_param_list(plist, ai_map)) {
     if (DCPS::DCPS_debug_level > 0) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::process_participant_ice - ")
                 ACE_TEXT("failed to convert from ParameterList to ")
                 ACE_TEXT("ICE::AgentInfo\n")));
     }
     return;
   }
   ICE::AgentInfoMap::const_iterator sedp_pos = ai_map.find(SEDP_AGENT_INFO_KEY);
   ICE::AgentInfoMap::const_iterator spdp_pos = ai_map.find(SPDP_AGENT_INFO_KEY);
 
   DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint;
   DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint;
   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     if (!initialized_flag_ || shutdown_flag_) {
       return;
     }
     if (sedp_) {
       sedp_endpoint = sedp_->get_ice_endpoint();
     }
     if (tport_) {
       spdp_endpoint = tport_->get_ice_endpoint();
     }
     DiscoveredParticipantIter iter = participants_.find(guid);
     if (iter != participants_.end()) {
       if (sedp_pos != ai_map.end()) {
         iter->second.have_sedp_info_ = true;
         iter->second.sedp_info_ = sedp_pos->second;
       } else {
         iter->second.have_sedp_info_ = false;
       }
 
       if (spdp_pos != ai_map.end()) {
         iter->second.have_spdp_info_ = true;
         iter->second.spdp_info_ = spdp_pos->second;
       } else {
         iter->second.have_spdp_info_ = false;
       }
     }
   }
 
   if (sedp_endpoint) {
     if (sedp_pos != ai_map.end()) {
       start_ice(sedp_endpoint, guid, pdata.participantProxy.availableBuiltinEndpoints,
                 pdata.participantProxy.availableExtendedBuiltinEndpoints, sedp_pos->second);
     } else {
       stop_ice(sedp_endpoint, guid, pdata.participantProxy.availableBuiltinEndpoints,
                pdata.participantProxy.availableExtendedBuiltinEndpoints);
     }
   }
 
   if (spdp_endpoint) {
     if (spdp_pos != ai_map.end()) {
       ice_agent_->start_ice(spdp_endpoint, guid_, guid, spdp_pos->second);
     } else {
       ice_agent_->stop_ice(spdp_endpoint, guid_, guid);
 #ifndef DDS_HAS_MINIMUM_BIT
       ACE_GUARD(ACE_Thread_Mutex, g, lock_);
       DiscoveredParticipantIter iter = participants_.find(guid);
       if (iter != participants_.end()) {
         enqueue_location_update_i(iter, DCPS::LOCATION_ICE, ACE_INET_Addr(), "stop ice");
         process_location_updates_i(iter, "stop ice");
       }
 #endif
     }
   }
 }

◆ publish_location_update_i()

void OpenDDS::RTPS::Spdp::publish_location_update_i ( const DiscoveredParticipantIter & iter )

protected

Definition at line 602 of file Spdp.cpp.

References ACE_DEBUG, bit_subscriber_, OpenDDS::DCPS::LogGuid::c_str(), LM_DEBUG, OpenDDS::DCPS::log_bits, and DDS::NEW_VIEW_STATE.

Referenced by process_location_updates_i().

 {
   iter->second.location_ih_ = bit_subscriber_->add_participant_location(iter->second.location_data_, DDS::NEW_VIEW_STATE);
   if (DCPS::log_bits) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) DEBUG: Spdp::publish_location_update_i: %@ participant %C has participant location handle %d\n", this, LogGuid(iter->first).c_str(), iter->second.location_ih_));
   }
 }

◆ purge_discovered_participant()

void OpenDDS::RTPS::Spdp::purge_discovered_participant ( const DiscoveredParticipantIter & iter )

protected

Definition at line 4695 of file Spdp.cpp.

References access(), ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::AUTH_STATE_HANDSHAKE, bit_subscriber_, OpenDDS::DCPS::LogGuid::c_str(), DDS::Security::SecurityException::code, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::Sedp::disassociate(), endpoint_manager(), DDS::HANDLE_NIL, LM_DEBUG, LM_WARNING, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, n_participants_in_authentication_, participants_, remove_lease_expiration_i(), security_config_, OpenDDS::DCPS::security_debug, and sedp_.

Referenced by handle_participant_data(), ignore_domain_participant(), process_handshake_deadlines(), process_lease_expirations(), remove_domain_participant(), shutdown(), and update_rtps_relay_application_participant_i().

 {
   if (iter == participants_.end()) {
     return;
   }
   endpoint_manager().disassociate(iter->second);
   bit_subscriber_->remove_participant(iter->second.bit_ih_, iter->second.location_ih_);
   if (DCPS_debug_level > 3) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) LocalParticipant::purge_discovered_participant: "
                "erasing %C (%B)\n",
                DCPS::LogGuid(iter->first).c_str(), participants_.size()));
   }
 
   remove_lease_expiration_i(iter);
 
 #ifdef OPENDDS_SECURITY
   if (security_config_) {
     DDS::Security::SecurityException se = {"", 0, 0};
     DDS::Security::Authentication_var auth = security_config_->get_authentication();
     DDS::Security::AccessControl_var access = security_config_->get_access_control();
 
     DDS::Security::ParticipantCryptoHandle pch =
       sedp_->get_handle_registry()->get_remote_participant_crypto_handle(iter->first);
     if (!security_config_->get_crypto_key_factory()->unregister_participant(pch, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                    ACE_TEXT("Spdp::purge_discovered_participant() - ")
                    ACE_TEXT("Unable to return crypto handle. ")
                    ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
     }
     sedp_->get_handle_registry()->erase_remote_participant_crypto_handle(iter->first);
     sedp_->get_handle_registry()->erase_remote_participant_permissions_handle(iter->first);
 
     if (iter->second.identity_handle_ != DDS::HANDLE_NIL) {
       if (!auth->return_identity_handle(iter->second.identity_handle_, se)) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                      ACE_TEXT("Spdp::purge_discovered_participant() - ")
                      ACE_TEXT("Unable to return identity handle. ")
                      ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                      se.code, se.minor_code, se.message.in()));
         }
       }
     }
 
     if (iter->second.handshake_handle_ != DDS::HANDLE_NIL) {
       if (!auth->return_handshake_handle(iter->second.handshake_handle_, se)) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                      ACE_TEXT("Spdp::purge_discovered_participant() - ")
                      ACE_TEXT("Unable to return handshake handle. ")
                      ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                      se.code, se.minor_code, se.message.in()));
         }
       }
     }
 
     if (iter->second.shared_secret_handle_ != 0) {
       if (!auth->return_sharedsecret_handle(iter->second.shared_secret_handle_, se)) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                      ACE_TEXT("Spdp::purge_discovered_participant() - ")
                      ACE_TEXT("Unable to return sharedsecret handle. ")
                      ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                      se.code, se.minor_code, se.message.in()));
         }
       }
     }
 
     if (iter->second.permissions_handle_ != DDS::HANDLE_NIL) {
       if (!access->return_permissions_handle(iter->second.permissions_handle_, se)) {
         if (DCPS::security_debug.auth_warn) {
           ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                      ACE_TEXT("Spdp::purge_discovered_participant() - ")
                      ACE_TEXT("Unable to return permissions handle. ")
                      ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                      se.code, se.minor_code, se.message.in()));
         }
       }
     }
   }
 
   if (iter->second.auth_state_ == AUTH_STATE_HANDSHAKE) {
     --n_participants_in_authentication_;
   }
 #endif
 }

◆ purge_handshake_deadlines()

void OpenDDS::RTPS::Spdp::purge_handshake_deadlines ( DiscoveredParticipantIter iter )

private

Definition at line 4337 of file Spdp.cpp.

References handshake_deadlines_, participants_, and purge_handshake_resends().

Referenced by attempt_authentication(), handle_handshake_message(), handle_participant_data(), process_lease_expirations(), and shutdown().

 {
   if (iter == participants_.end()) {
     return;
   }
 
   purge_handshake_resends(iter);
 
   std::pair<TimeQueue::iterator, TimeQueue::iterator> range = handshake_deadlines_.equal_range(iter->second.handshake_deadline_);
   for (; range.first != range.second; ++range.first) {
     if (range.first->second == iter->first) {
       handshake_deadlines_.erase(range.first);
       break;
     }
   }
 }

◆ purge_handshake_resends()

void OpenDDS::RTPS::Spdp::purge_handshake_resends ( DiscoveredParticipantIter iter )

private

Definition at line 4354 of file Spdp.cpp.

References config_, handshake_resends_, and participants_.

Referenced by process_handshake_deadlines(), and purge_handshake_deadlines().

 {
   if (iter == participants_.end()) {
     return;
   }
 
   iter->second.have_auth_req_msg_ = false;
   iter->second.have_handshake_msg_ = false;
   iter->second.handshake_resend_falloff_.set(config_->auth_resend_period());
 
   std::pair<TimeQueue::iterator, TimeQueue::iterator> range = handshake_resends_.equal_range(iter->second.stateless_msg_deadline_);
   for (; range.first != range.second; ++range.first) {
     if (range.first->second == iter->first) {
       handshake_resends_.erase(range.first);
       break;
     }
   }
 }

◆ remote_crypto_handle()

DDS::Security::ParticipantCryptoHandle OpenDDS::RTPS::Spdp::remote_crypto_handle ( const DCPS::GUID_t & remote_participant ) const

Definition at line 4150 of file Spdp.cpp.

References sedp_.

 {
   return sedp_->get_handle_registry()->get_remote_participant_crypto_handle(remote_participant);
 }

◆ remove_agent_info()

void OpenDDS::RTPS::Spdp::remove_agent_info ( const DCPS::GUID_t & local_guid )

privatevirtual

Implements OpenDDS::ICE::AgentInfoListener.

Definition at line 2146 of file Spdp.cpp.

References is_security_enabled(), and write_secure_updates().

 {
   if (is_security_enabled()) {
     write_secure_updates();
   }
 }

◆ remove_domain_participant()

void OpenDDS::RTPS::Spdp::remove_domain_participant ( const GUID_t & removeId )

Definition at line 4656 of file Spdp.cpp.

References ACE_GUARD, lock_, participants_, and purge_discovered_participant().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   DiscoveredParticipantIter iter = participants_.find(removeId);
   if (iter != participants_.end()) {
     purge_discovered_participant(iter);
     participants_.erase(iter);
   }
 }

◆ remove_lease_expiration_i()

void OpenDDS::RTPS::Spdp::remove_lease_expiration_i ( DiscoveredParticipantIter iter )

private

Definition at line 3704 of file Spdp.cpp.

References lease_expirations_.

Referenced by purge_discovered_participant(), and update_lease_expiration_i().

 {
   for (std::pair<TimeQueue::iterator, TimeQueue::iterator> x = lease_expirations_.equal_range(iter->second.lease_expiration_);
        x.first != x.second; ++x.first) {
     if (x.first->second == iter->first) {
       lease_expirations_.erase(x.first);
       break;
     }
   }
 }

◆ remove_publication()

void OpenDDS::RTPS::Spdp::remove_publication ( const GUID_t & publicationId )

inline

Definition at line 272 of file Spdp.h.

   {
     endpoint_manager().remove_publication(publicationId);
   }

◆ remove_subscription()

void OpenDDS::RTPS::Spdp::remove_subscription ( const GUID_t & subscriptionId )

inline

Definition at line 312 of file Spdp.h.

   {
     endpoint_manager().remove_subscription(subscriptionId);
   }

◆ remove_topic()

DCPS::TopicStatus OpenDDS::RTPS::Spdp::remove_topic ( const GUID_t & topicId )

inline

Definition at line 244 of file Spdp.h.

   {
     return endpoint_manager().remove_topic(topicId);
   }

◆ request_remote_complete_type_objects()

void OpenDDS::RTPS::Spdp::request_remote_complete_type_objects	(	const GUID_t &	remote_entity,
		const XTypes::TypeInformation &	remote_type_info,
		DCPS::TypeObjReqCond &	cond
	)

inline

Definition at line 346 of file Spdp.h.

   {
     sedp_->request_remote_complete_type_objects(remote_entity, remote_type_info, cond);
   }

◆ rtps_relay_only_now()

void OpenDDS::RTPS::Spdp::rtps_relay_only_now ( bool f )

Definition at line 4473 of file Spdp.cpp.

References ACE_GUARD, config_, enqueue_location_update_i(), OpenDDS::DCPS::LOCATION_ICE, OpenDDS::DCPS::LOCATION_ICE6, OpenDDS::DCPS::LOCATION_LOCAL, OpenDDS::DCPS::LOCATION_LOCAL6, lock_, participants_, process_location_updates_i(), sedp_, tport_, and OpenDDS::DCPS::TimeDuration::zero_value.

 {
   ACE_UNUSED_ARG(flag);
 
 #ifdef OPENDDS_SECURITY
   sedp_->rtps_relay_only_now(flag);
 
   if (flag) {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
     tport_->relay_spdp_task_falloff_.set(config_->sedp_heartbeat_period());
     tport_->relay_spdp_task_->schedule(TimeDuration::zero_value);
 
     tport_->relay_stun_task_falloff_.set(config_->sedp_heartbeat_period());
     tport_->relay_stun_task_->schedule(TimeDuration::zero_value);
 
 #ifndef DDS_HAS_MINIMUM_BIT
     const DCPS::ParticipantLocation mask =
       DCPS::LOCATION_LOCAL |
       DCPS::LOCATION_LOCAL6 |
       DCPS::LOCATION_ICE |
       DCPS::LOCATION_ICE6;
 
     for (DiscoveredParticipantIter iter = participants_.begin();
          iter != participants_.end();
          ++iter) {
       enqueue_location_update_i(iter, mask, ACE_INET_Addr(), "rtps_relay_only_now");
       process_location_updates_i(iter, "rtps_relay_only_now");
     }
 #endif
   } else {
     if (!config_->use_rtps_relay()) {
       if (tport_->relay_spdp_task_) {
         tport_->relay_spdp_task_->cancel();
       }
       if (tport_->relay_stun_task_) {
         tport_->disable_relay_stun_task();
       }
     }
   }
 #endif
 }

◆ schedule_handshake_resend()

MonotonicTimePoint OpenDDS::RTPS::Spdp::schedule_handshake_resend	(	const DCPS::TimeDuration &	time,
		const DCPS::GUID_t &	guid
	)

private

Definition at line 1959 of file Spdp.cpp.

References handshake_resends_, and tport_.

Referenced by attempt_authentication(), and send_handshake_message().

 {
   const MonotonicTimePoint deadline = MonotonicTimePoint::now() + time;
   handshake_resends_.insert(std::make_pair(deadline, guid));
   if (deadline < handshake_resends_.begin()->first) {
     tport_->handshake_resend_task_->cancel();
   }
   tport_->handshake_resend_task_->schedule(time);
   return deadline;
 }

◆ secure_part_user_data()

bool OpenDDS::RTPS::Spdp::secure_part_user_data ( ) const

private

If this is true participant user data should only be sent and received securely, otherwise the user data should be empty and participant bit updates should be withheld from the user.

Definition at line 4619 of file Spdp.cpp.

References config_, and security_enabled_.

Referenced by get_part_bit_data(), handle_participant_data(), and match_unauthenticated().

 {
 #ifdef OPENDDS_SECURITY
   return security_enabled_ && config_->secure_participant_user_data();
 #else
   return false;
 #endif
 }

◆ sedp_rtps_relay_address()

void OpenDDS::RTPS::Spdp::sedp_rtps_relay_address ( const ACE_INET_Addr & address )

inline

Definition at line 198 of file Spdp.h.

198 { sedp_->rtps_relay_address(address); }

OpenDDS::RTPS::Spdp::sedp_

DCPS::RcHandle< Sedp > sedp_

Definition: Spdp.h:606

◆ sedp_stun_server_address()

void OpenDDS::RTPS::Spdp::sedp_stun_server_address ( const ACE_INET_Addr & address )

inline

Definition at line 199 of file Spdp.h.

199 { sedp_->stun_server_address(address); }

OpenDDS::RTPS::Spdp::sedp_

DCPS::RcHandle< Sedp > sedp_

Definition: Spdp.h:606

◆ sedp_transport_inst()

RcHandle<DCPS::TransportInst> OpenDDS::RTPS::Spdp::sedp_transport_inst ( ) const

inline

Definition at line 341 of file Spdp.h.

   {
     return sedp_->transport_inst();
   }

◆ send_handshake_message()

DDS::ReturnCode_t OpenDDS::RTPS::Spdp::send_handshake_message	(	const DCPS::GUID_t &	guid,
		DiscoveredParticipant &	dp,
		const DDS::Security::ParticipantStatelessMessage &	msg
	)

private

Definition at line 1945 of file Spdp.cpp.

References OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER, guid(), OpenDDS::RTPS::DiscoveredParticipant::handshake_msg_, OpenDDS::RTPS::DiscoveredParticipant::handshake_resend_falloff_, OpenDDS::RTPS::DiscoveredParticipant::have_handshake_msg_, OpenDDS::DCPS::make_id(), DDS::Security::ParticipantGenericMessage::message_identity, schedule_handshake_resend(), sedp_, DDS::Security::MessageIdentity::sequence_number, OpenDDS::RTPS::DiscoveredParticipant::stateless_msg_deadline_, and stateless_sequence_number_.

Referenced by handle_handshake_message(), and send_handshake_request().

 {
   dp.handshake_msg_ = msg;
   dp.handshake_msg_.message_identity.sequence_number = (++stateless_sequence_number_).getValue();
 
   const DCPS::GUID_t reader = make_id(guid, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER);
   const DDS::ReturnCode_t retval = sedp_->write_stateless_message(dp.handshake_msg_, reader);
   dp.have_handshake_msg_ = true;
   dp.stateless_msg_deadline_ = schedule_handshake_resend(dp.handshake_resend_falloff_.get(), guid);
   return retval;
 }

◆ send_handshake_request()

void OpenDDS::RTPS::Spdp::send_handshake_request	(	const DCPS::GUID_t &	guid,
		DiscoveredParticipant &	dp
	)

Definition at line 1274 of file Spdp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), DDS::Security::SecurityException::code, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, DDS::Security::ParticipantGenericMessage::destination_participant_guid, DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE, guid(), guid_, OpenDDS::DCPS::GUID_UNKNOWN, DDS::HANDLE_NIL, OpenDDS::RTPS::DiscoveredParticipant::handshake_handle_, OpenDDS::RTPS::DiscoveredParticipant::handshake_state_, OpenDDS::RTPS::HANDSHAKE_STATE_BEGIN_HANDSHAKE_REQUEST, OpenDDS::RTPS::HANDSHAKE_STATE_PROCESS_HANDSHAKE, OpenDDS::RTPS::DiscoveredParticipant::identity_handle_, identity_handle_, LM_DEBUG, LM_ERROR, LM_WARNING, local_participant_data_as_octets(), DDS::Security::SecurityException::message, DDS::Security::ParticipantGenericMessage::message_class_id, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, DDS::Security::SecurityException::minor_code, OPENDDS_ASSERT, DDS::Security::ParticipantGenericMessage::related_message_identity, DDS::RETCODE_OK, security_config_, OpenDDS::DCPS::security_debug, send_handshake_message(), DDS::Security::MessageIdentity::sequence_number, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, DDS::Security::MessageIdentity::source_guid, and DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE.

Referenced by attempt_authentication().

 {
   OPENDDS_ASSERT(dp.handshake_state_ == HANDSHAKE_STATE_BEGIN_HANDSHAKE_REQUEST);
 
   Security::Authentication_var auth = security_config_->get_authentication();
   DDS::Security::SecurityException se = {"", 0, 0};
   if (dp.handshake_handle_ != DDS::HANDLE_NIL) {
     // Return the handle for reauth.
     if (!auth->return_handshake_handle(dp.handshake_handle_, se)) {
       if (DCPS::security_debug.auth_warn) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) {auth_warn} ")
                    ACE_TEXT("Spdp::send_handshake_request() - ")
                    ACE_TEXT("Unable to return handshake handle. ")
                    ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                    se.code, se.minor_code, se.message.in()));
       }
       return;
     }
     dp.handshake_handle_ = DDS::HANDLE_NIL;
   }
 
   const DDS::OctetSeq local_participant = local_participant_data_as_octets();
   if (!local_participant.length()) {
     return; // already logged in local_participant_data_as_octets()
   }
 
   DDS::Security::HandshakeMessageToken hs_mt;
   if (auth->begin_handshake_request(dp.handshake_handle_, hs_mt, identity_handle_, dp.identity_handle_,
                                     local_participant, se)
       != DDS::Security::VALIDATION_PENDING_HANDSHAKE_MESSAGE) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::send_handshake_request() - ")
                ACE_TEXT("Failed to begin handshake_request. Security Exception[%d.%d]: %C\n"),
                se.code, se.minor_code, se.message.in()));
     return;
   }
 
   dp.handshake_state_ = HANDSHAKE_STATE_PROCESS_HANDSHAKE;
 
   DDS::Security::ParticipantStatelessMessage msg = DDS::Security::ParticipantStatelessMessage();
   msg.message_identity.source_guid = guid_;
   msg.message_identity.sequence_number = 0;
   msg.message_class_id = DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE;
   msg.destination_participant_guid = guid;
   msg.destination_endpoint_guid = GUID_UNKNOWN;
   msg.source_endpoint_guid = GUID_UNKNOWN;
   msg.related_message_identity.source_guid = GUID_UNKNOWN;
   msg.related_message_identity.sequence_number = 0;
   msg.message_data.length(1);
   msg.message_data[0] = hs_mt;
 
   if (send_handshake_message(guid, dp, msg) != DDS::RETCODE_OK) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::send_handshake_request() - ")
                ACE_TEXT("Unable to write stateless message (handshake).\n")));
     return;
   } else if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Spdp::send_handshake_request() - ")
                ACE_TEXT("Sent handshake request message for participant: %C\n"),
                DCPS::LogGuid(guid).c_str()));
   }
 }

◆ send_participant_crypto_tokens()

void OpenDDS::RTPS::Spdp::send_participant_crypto_tokens ( const DCPS::GUID_t & id )

Definition at line 3801 of file Spdp.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::DCPS::DCPS_debug_level, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, OpenDDS::DCPS::ENTITYID_PARTICIPANT, DDS::Security::GMCLASSID_SECURITY_PARTICIPANT_CRYPTO_TOKENS, guid_, OpenDDS::DCPS::GUID_UNKNOWN, LM_ERROR, OpenDDS::DCPS::make_id(), DDS::Security::ParticipantGenericMessage::message_class_id, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, participants_, DDS::Security::ParticipantGenericMessage::related_message_identity, DDS::RETCODE_OK, sedp_, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, and DDS::Security::MessageIdentity::source_guid.

Referenced by OpenDDS::RTPS::Sedp::association_complete_i().

 {
   const DCPS::GUID_t peer = make_id(id, ENTITYID_PARTICIPANT);
   const DiscoveredParticipantIter iter = participants_.find(peer);
   if (iter == participants_.end()) {
     if (DCPS::DCPS_debug_level > 0) {
       const DCPS::LogGuid logger(peer);
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::send_participant_crypto_tokens() - ")
                 ACE_TEXT("Discovered participant %C not found.\n"),
                 logger.c_str()));
     }
     return;
   }
 
   const DDS::Security::ParticipantCryptoTokenSeq& pcts = iter->second.crypto_tokens_;
 
   if (pcts.length() != 0) {
     const DCPS::GUID_t writer = make_id(guid_, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
 
     const DCPS::GUID_t reader = make_id(peer, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
 
     DDS::Security::ParticipantVolatileMessageSecure msg;
     msg.message_identity.source_guid = writer;
     msg.related_message_identity.source_guid = GUID_UNKNOWN;
     msg.message_class_id = DDS::Security::GMCLASSID_SECURITY_PARTICIPANT_CRYPTO_TOKENS;
     msg.destination_participant_guid = peer;
     msg.destination_endpoint_guid = GUID_UNKNOWN; // unknown = whole participant
     msg.source_endpoint_guid = GUID_UNKNOWN;
     msg.message_data = reinterpret_cast<const DDS::Security::DataHolderSeq&>(pcts);
 
     if (sedp_->write_volatile_message(msg, reader) != DDS::RETCODE_OK) {
       if (DCPS::DCPS_debug_level > 0) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::send_participant_crypto_tokens() - ")
           ACE_TEXT("Unable to write volatile message.\n")));
       }
     }
   }
 
   iter->second.participant_tokens_sent_ = true;
 }

◆ set_auth_state()

void OpenDDS::RTPS::Spdp::set_auth_state	(	DiscoveredParticipant &	dp,
		AuthState	state
	)

private

Definition at line 4786 of file Spdp.cpp.

References OpenDDS::RTPS::DiscoveredParticipant::auth_state_, OpenDDS::RTPS::AUTH_STATE_HANDSHAKE, n_participants_in_authentication_, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

Referenced by attempt_authentication(), handle_handshake_message(), handle_participant_data(), and process_handshake_deadlines().

 {
   if (dp.auth_state_ == AUTH_STATE_HANDSHAKE &&
       new_state != AUTH_STATE_HANDSHAKE) {
     --n_participants_in_authentication_;
   }
   dp.auth_state_ = new_state;
 }

◆ shutdown()

void OpenDDS::RTPS::Spdp::shutdown ( void )

Definition at line 361 of file Spdp.cpp.

References CORBA::Exception::_info(), ACE_DEBUG, ACE_ERROR, ACE_GUARD, ACE_TEXT(), ACE_String_Base< char >::c_str(), OpenDDS::DCPS::DCPS_debug_level, eh_shutdown_, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, guid_, ice_agent_, LM_ERROR, LM_INFO, lock_, OpenDDS::DCPS::make_id(), participants_, purge_discovered_participant(), purge_handshake_deadlines(), sedp_, shutdown_cond_, shutdown_flag_, stop_ice(), TheServiceParticipant, tport_, OpenDDS::DCPS::ConditionVariable< Mutex >::wait(), and write_secure_disposes().

 {
   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     shutdown_flag_ = true;
     if (DCPS::DCPS_debug_level > 3) {
       ACE_DEBUG((LM_INFO,
                  ACE_TEXT("(%P|%t) Spdp::~Spdp ")
                  ACE_TEXT("remove discovered participants\n")));
     }
 
 #ifdef OPENDDS_SECURITY
     try {
       write_secure_disposes();
     } catch (const CORBA::Exception& e) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Spdp::~Spdp() - from ")
                  ACE_TEXT("write_secure_disposes: %C\n"), e._info().c_str()));
     }
 #endif
 
     for (DiscoveredParticipantIter part = participants_.begin(); part != participants_.end(); ++part) {
 #ifdef OPENDDS_SECURITY
       DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
       if (sedp_endpoint) {
         stop_ice(sedp_endpoint, part->first, part->second.pdata_.participantProxy.availableBuiltinEndpoints,
                  part->second.pdata_.participantProxy.availableExtendedBuiltinEndpoints);
       }
       DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint = tport_->get_ice_endpoint();
       if (spdp_endpoint) {
         ice_agent_->stop_ice(spdp_endpoint, guid_, part->first);
       }
       purge_handshake_deadlines(part);
 #endif
       purge_discovered_participant(part);
     }
   }
 
 #ifdef OPENDDS_SECURITY
   DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
   if (sedp_endpoint) {
     const GUID_t l = make_id(guid_, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER);
     ice_agent_->remove_local_agent_info_listener(sedp_endpoint, l);
   }
 #endif
 
   // ensure sedp's task queue is drained before data members are being
   // deleted
   sedp_->shutdown();
 
   // release lock for reset of event handler, which may delete transport
   tport_->close(sedp_->reactor_task());
   tport_.reset();
   {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     DCPS::ThreadStatusManager& thread_status_manager = TheServiceParticipant->get_thread_status_manager();
     while (!eh_shutdown_) {
       shutdown_cond_.wait(thread_status_manager);
     }
   }
 }

◆ shutting_down()

bool OpenDDS::RTPS::Spdp::shutting_down ( void )

inline

Definition at line 118 of file Spdp.h.

Referenced by OpenDDS::RTPS::Sedp::associate(), OpenDDS::RTPS::Sedp::data_received(), OpenDDS::RTPS::Sedp::process_discovered_reader_data(), OpenDDS::RTPS::Sedp::process_discovered_writer_data(), OpenDDS::RTPS::Sedp::received_participant_message_data_secure(), OpenDDS::RTPS::Sedp::received_stateless_message(), OpenDDS::RTPS::Sedp::received_volatile_message_secure(), OpenDDS::RTPS::Sedp::remove_entities_belonging_to(), and OpenDDS::RTPS::Sedp::shutting_down().

   {
     return shutdown_flag_;
   }

◆ signal_liveliness()

void OpenDDS::RTPS::Spdp::signal_liveliness ( DDS::LivelinessQosPolicyKind kind )

Definition at line 3394 of file Spdp.cpp.

References sedp_.

 {
   sedp_->signal_liveliness(kind);
 }

◆ spdp_rtps_relay_address_change()

void OpenDDS::RTPS::Spdp::spdp_rtps_relay_address_change ( )

Definition at line 2786 of file Spdp.cpp.

References ACE_GUARD, config_, lock_, tport_, and OpenDDS::DCPS::TimeDuration::zero_value.

 {
 #ifdef OPENDDS_SECURITY
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   tport_->relay_spdp_task_->cancel();
   tport_->relay_spdp_task_falloff_.set(config_->sedp_heartbeat_period());
   tport_->relay_spdp_task_->schedule(TimeDuration::zero_value);
 
   tport_->relay_stun_task_->cancel();
   tport_->relay_stun_task_falloff_.set(config_->sedp_heartbeat_period());
   tport_->relay_stun_task_->schedule(TimeDuration::zero_value);
 #endif
 }

◆ start_ice()

void OpenDDS::RTPS::Spdp::start_ice	(	DCPS::WeakRcHandle< ICE::Endpoint >	endpoint,
		DCPS::GUID_t	remote,
		BuiltinEndpointSet_t	avail,
		DDS::Security::ExtendedBuiltinEndpointSet_t	extended_avail,
		const ICE::AgentInfo &	agent_info
	)

private

Definition at line 3867 of file Spdp.cpp.

Referenced by process_participant_ice(), and use_ice_now().

 {
   GUID_t l = guid_;
 
   // See RTPS v2.1 section 8.5.5.1
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER) {
     l.entityId = ENTITYID_TL_SVC_REQ_READER;
     r.entityId = ENTITYID_TL_SVC_REQ_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER) {
     l.entityId = ENTITYID_TL_SVC_REQ_WRITER;
     r.entityId = ENTITYID_TL_SVC_REQ_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER) {
     l.entityId = ENTITYID_TL_SVC_REPLY_READER;
     r.entityId = ENTITYID_TL_SVC_REPLY_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER) {
     l.entityId = ENTITYID_TL_SVC_REPLY_WRITER;
     r.entityId = ENTITYID_TL_SVC_REPLY_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
 
   using namespace DDS::Security;
   // See DDS-Security v1.1 section 7.3.7.1
   if (avail & SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER) {
     l.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
     r.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (avail & SPDP_BUILTIN_PARTICIPANT_SECURE_READER) {
     l.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
     r.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REQ_READER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REQ_WRITER_SECURE;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REQ_WRITER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REQ_READER_SECURE;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REPLY_READER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REPLY_WRITER_SECURE;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REPLY_WRITER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REPLY_READER_SECURE;
     ice_agent_->start_ice(endpoint, l, r, agent_info);
   }
 }

◆ stop_ice()

void OpenDDS::RTPS::Spdp::stop_ice	(	DCPS::WeakRcHandle< ICE::Endpoint >	endpoint,
		DCPS::GUID_t	remote,
		BuiltinEndpointSet_t	avail,
		DDS::Security::ExtendedBuiltinEndpointSet_t	extended_avail
	)

private

Definition at line 4009 of file Spdp.cpp.

Referenced by handle_participant_data(), process_handshake_deadlines(), process_lease_expirations(), process_participant_ice(), and shutdown().

                                                                             {
   GUID_t l = guid_;
 
   // See RTPS v2.1 section 8.5.5.1
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER) {
     l.entityId = ENTITYID_TL_SVC_REQ_READER;
     r.entityId = ENTITYID_TL_SVC_REQ_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER) {
     l.entityId = ENTITYID_TL_SVC_REQ_WRITER;
     r.entityId = ENTITYID_TL_SVC_REQ_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER) {
     l.entityId = ENTITYID_TL_SVC_REPLY_READER;
     r.entityId = ENTITYID_TL_SVC_REPLY_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER) {
     l.entityId = ENTITYID_TL_SVC_REPLY_WRITER;
     r.entityId = ENTITYID_TL_SVC_REPLY_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
 
   using namespace DDS::Security;
   // See DDS-Security v1.1 section 7.3.7.1
   if (avail & SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) {
     l.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER;
     r.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER) {
     l.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER;
     r.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER) {
     l.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
     r.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (avail & SPDP_BUILTIN_PARTICIPANT_SECURE_READER) {
     l.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
     r.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REQ_READER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REQ_WRITER_SECURE;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REQ_WRITER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REQ_READER_SECURE;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REPLY_READER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REPLY_WRITER_SECURE;
     ice_agent_->stop_ice(endpoint, l, r);
   }
   if (extended_avail & TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE) {
     l.entityId = ENTITYID_TL_SVC_REPLY_WRITER_SECURE;
     r.entityId = ENTITYID_TL_SVC_REPLY_READER_SECURE;
     ice_agent_->stop_ice(endpoint, l, r);
   }
 }

◆ update_agent_info()

void OpenDDS::RTPS::Spdp::update_agent_info	(	const DCPS::GUID_t &	local_guid,
		const ICE::AgentInfo &	agent_info
	)

privatevirtual

Implements OpenDDS::ICE::AgentInfoListener.

Definition at line 2139 of file Spdp.cpp.

References is_security_enabled(), and write_secure_updates().

 {
   if (is_security_enabled()) {
     write_secure_updates();
   }
 }

◆ update_domain_participant_qos()

bool OpenDDS::RTPS::Spdp::update_domain_participant_qos ( const DDS::DomainParticipantQos & qos )

Definition at line 4667 of file Spdp.cpp.

References ACE_GUARD_RETURN, announce_domain_participant_qos(), lock_, and qos_.

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   qos_ = qos;
   return announce_domain_participant_qos();
 }

◆ update_lease_expiration_i()

void OpenDDS::RTPS::Spdp::update_lease_expiration_i	(	DiscoveredParticipantIter	iter,
		const DCPS::MonotonicTimePoint &	now
	)

private

Definition at line 3716 of file Spdp.cpp.

References lease_expirations_, lease_extension_, remove_lease_expiration_i(), OpenDDS::RTPS::rtps_duration_to_time_duration(), OpenDDS::DCPS::InternalDataReaderListener< DCPS::NetworkInterfaceAddress >::schedule(), and tport_.

Referenced by handle_participant_data().

 {
   remove_lease_expiration_i(iter);
 
   // Compute new expiration.
   const DCPS::TimeDuration d =
     rtps_duration_to_time_duration(iter->second.pdata_.leaseDuration,
                                    iter->second.pdata_.participantProxy.protocolVersion,
                                    iter->second.pdata_.participantProxy.vendorId);
 
   iter->second.lease_expiration_ = now + d + lease_extension_;
 
   // Insert.
   const bool cancel = !lease_expirations_.empty() && iter->second.lease_expiration_ < lease_expirations_.begin()->first;
   const bool schedule = lease_expirations_.empty() || iter->second.lease_expiration_ < lease_expirations_.begin()->first;
 
   lease_expirations_.insert(std::make_pair(iter->second.lease_expiration_, iter->first));
 
   if (cancel) {
     tport_->lease_expiration_task_->cancel();
   }
   if (schedule) {
     tport_->lease_expiration_task_->schedule(d);
   }
 }

◆ update_publication_locators()

void OpenDDS::RTPS::Spdp::update_publication_locators	(	const GUID_t &	publicationId,
		const DCPS::TransportLocatorSeq &	transInfo
	)

inline

Definition at line 291 of file Spdp.h.

   {
     endpoint_manager().update_publication_locators(publicationId, transInfo);
   }

◆ update_publication_qos()

bool OpenDDS::RTPS::Spdp::update_publication_qos	(	const GUID_t &	publicationId,
		const DDS::DataWriterQos &	qos,
		const DDS::PublisherQos &	publisherQos
	)

inline

Definition at line 283 of file Spdp.h.

   {
     return endpoint_manager().update_publication_qos(publicationId, qos, publisherQos);
   }

◆ update_rtps_relay_application_participant_i()

void OpenDDS::RTPS::Spdp::update_rtps_relay_application_participant_i	(	DiscoveredParticipantIter	iter,
		bool	new_participant
	)

private

Definition at line 2750 of file Spdp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), config_, OpenDDS::DCPS::DCPS_debug_level, LM_DEBUG, participants_, purge_discovered_participant(), tport_, and OpenDDS::DCPS::TimeDuration::zero_value.

Referenced by handle_participant_data().

 {
   if (!iter->second.pdata_.participantProxy.opendds_rtps_relay_application_participant) {
     return;
   }
 
   if (new_participant) {
 #ifdef OPENDDS_SECURITY
     tport_->relay_spdp_task_->cancel();
     tport_->relay_spdp_task_falloff_.set(config_->sedp_heartbeat_period());
     tport_->relay_spdp_task_->schedule(TimeDuration::zero_value);
 #endif
   }
 
   if (DCPS::DCPS_debug_level) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Spdp::update_rtps_relay_application_participant - %C is an RtpsRelay application participant\n"),
                DCPS::LogGuid(iter->first).c_str()));
   }
 
   for (DiscoveredParticipantIter pos = participants_.begin(), limit = participants_.end(); pos != limit;) {
     if (pos != iter && pos->second.pdata_.participantProxy.opendds_rtps_relay_application_participant) {
       if (DCPS::DCPS_debug_level) {
         ACE_DEBUG((LM_DEBUG,
                    ACE_TEXT("(%P|%t) Spdp::update_rtps_relay_application_participant - removing previous RtpsRelay application participant %C\n"),
                    DCPS::LogGuid(pos->first).c_str()));
       }
       purge_discovered_participant(pos);
       participants_.erase(pos++);
     } else {
       ++pos;
     }
   }
 }

◆ update_subscription_locators()

void OpenDDS::RTPS::Spdp::update_subscription_locators	(	const GUID_t &	subId,
		const DCPS::TransportLocatorSeq &	transInfo
	)

inline

Definition at line 336 of file Spdp.h.

   {
     endpoint_manager().update_subscription_locators(subId, transInfo);
   }

◆ update_subscription_params()

bool OpenDDS::RTPS::Spdp::update_subscription_params	(	const GUID_t &	subId,
		const DDS::StringSeq &	params
	)

inline

Definition at line 331 of file Spdp.h.

   {
     return endpoint_manager().update_subscription_params(subId, params);
   }

◆ update_subscription_qos()

bool OpenDDS::RTPS::Spdp::update_subscription_qos	(	const GUID_t &	subscriptionId,
		const DDS::DataReaderQos &	qos,
		const DDS::SubscriberQos &	subscriberQos
	)

inline

Definition at line 323 of file Spdp.h.

   {
     return endpoint_manager().update_subscription_qos(subscriptionId, qos, subscriberQos);
   }

◆ update_topic_qos()

bool OpenDDS::RTPS::Spdp::update_topic_qos	(	const GUID_t &	topicId,
		const DDS::TopicQos &	qos
	)

inline

Definition at line 255 of file Spdp.h.

   {
     return endpoint_manager().update_topic_qos(topicId, qos);
   }

◆ use_ice_now()

void OpenDDS::RTPS::Spdp::use_ice_now ( bool f )

Definition at line 4561 of file Spdp.cpp.

References ACE_GUARD, enqueue_location_update_i(), OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, guid_, ice_agent_, is_security_enabled(), OpenDDS::DCPS::LOCATION_ICE, OpenDDS::DCPS::LOCATION_ICE6, lock_, OpenDDS::DCPS::make_id(), participants_, process_location_updates_i(), OpenDDS::DCPS::rchandle_from(), sedp_, start_ice(), tport_, and write_secure_updates().

 {
   ACE_UNUSED_ARG(flag);
 
 #ifdef OPENDDS_SECURITY
   sedp_->use_ice_now(flag);
 
   if (flag) {
     DCPS::WeakRcHandle<ICE::Endpoint> spdp_endpoint = tport_->get_ice_endpoint();
     DCPS::WeakRcHandle<ICE::Endpoint> sedp_endpoint = sedp_->get_ice_endpoint();
 
     if (sedp_endpoint) {
       const GUID_t l = make_id(guid_, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER);
       ice_agent_->add_local_agent_info_listener(sedp_endpoint, l, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(DCPS::rchandle_from(this)));
     }
 
     ice_agent_->add_endpoint(DCPS::static_rchandle_cast<ICE::Endpoint>(tport_));
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     tport_->ice_endpoint_added_ = true;
     if (spdp_endpoint) {
       ice_agent_->add_local_agent_info_listener(spdp_endpoint, guid_, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(DCPS::rchandle_from(this)));
     }
 
     for (DiscoveredParticipantConstIter pos = participants_.begin(), limit = participants_.end(); pos != limit; ++pos) {
       if (spdp_endpoint && pos->second.have_spdp_info_) {
         ice_agent_->start_ice(spdp_endpoint, guid_, pos->first, pos->second.spdp_info_);
       }
 
       if (sedp_endpoint && pos->second.have_sedp_info_) {
         start_ice(sedp_endpoint, pos->first, pos->second.pdata_.participantProxy.availableBuiltinEndpoints,
                   pos->second.pdata_.participantProxy.availableExtendedBuiltinEndpoints, pos->second.sedp_info_);
       }
     }
   } else {
     ice_agent_->remove_endpoint(DCPS::static_rchandle_cast<ICE::Endpoint>(tport_));
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     tport_->ice_endpoint_added_ = false;
 
 #ifndef DDS_HAS_MINIMUM_BIT
     const DCPS::ParticipantLocation mask =
       DCPS::LOCATION_ICE |
       DCPS::LOCATION_ICE6;
 
     for (DiscoveredParticipantIter part = participants_.begin();
          part != participants_.end();
          ++part) {
       enqueue_location_update_i(part, mask, ACE_INET_Addr(), "use_ice_now");
       process_location_updates_i(part, "use_ice_now");
     }
 #endif
   }
 
   if (is_security_enabled()) {
     write_secure_updates();
   }
 #endif
 }

◆ use_rtps_relay_now()

void OpenDDS::RTPS::Spdp::use_rtps_relay_now ( bool f )

Definition at line 4517 of file Spdp.cpp.

References ACE_GUARD, config_, enqueue_location_update_i(), OpenDDS::DCPS::LOCATION_RELAY, OpenDDS::DCPS::LOCATION_RELAY6, lock_, participants_, process_location_updates_i(), sedp_, tport_, and OpenDDS::DCPS::TimeDuration::zero_value.

 {
   ACE_UNUSED_ARG(f);
 
 #ifdef OPENDDS_SECURITY
   sedp_->use_rtps_relay_now(f);
 
   if (f) {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     tport_->relay_spdp_task_falloff_.set(config_->sedp_heartbeat_period());
     tport_->relay_spdp_task_->schedule(TimeDuration::zero_value);
 
     tport_->relay_stun_task_falloff_.set(config_->sedp_heartbeat_period());
     tport_->relay_stun_task_->schedule(TimeDuration::zero_value);
   } else {
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
     if (!config_->rtps_relay_only()) {
       if (tport_->relay_spdp_task_) {
         tport_->relay_spdp_task_->cancel();
       }
       if (tport_->relay_stun_task_) {
         tport_->disable_relay_stun_task();
       }
     }
 
 #ifndef DDS_HAS_MINIMUM_BIT
     const DCPS::ParticipantLocation mask =
       DCPS::LOCATION_RELAY |
       DCPS::LOCATION_RELAY6;
 
     for (DiscoveredParticipantIter iter = participants_.begin();
          iter != participants_.end();
          ++iter) {
       enqueue_location_update_i(iter, mask, ACE_INET_Addr(), "use_rtps_relay_now");
       process_location_updates_i(iter, "use_rtps_relay_now");
     }
 #endif
 
   }
 #endif
 }

◆ validateSequenceNumber()

bool OpenDDS::RTPS::Spdp::validateSequenceNumber	(	const DCPS::MonotonicTimePoint &	now,
		const DCPS::SequenceNumber &	seq,
		DiscoveredParticipantIter &	iter
	)

Definition at line 1030 of file Spdp.cpp.

References OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::DCPS::SequenceNumber::MAX_VALUE, and min_resend_delay_.

Referenced by handle_participant_data().

 {
   if (seq.getValue() != 0 && iter->second.max_seq_ != DCPS::SequenceNumber::MAX_VALUE) {
     if (seq < iter->second.max_seq_) {
       const bool honeymoon_period = now < iter->second.discovered_at_ + min_resend_delay_;
       if (!honeymoon_period) {
         ++iter->second.seq_reset_count_;
       }
       return false;
     } else if (iter->second.seq_reset_count_ > 0) {
       --iter->second.seq_reset_count_;
     }
   }
   iter->second.max_seq_ = std::max(iter->second.max_seq_, seq);
   return true;
 }

◆ write_secure_disposes()

void OpenDDS::RTPS::Spdp::write_secure_disposes ( )

Definition at line 441 of file Spdp.cpp.

References DDS::Security::ParticipantBuiltinTopicData::base, DDS::Security::ParticipantBuiltinTopicDataSecure::base, OpenDDS::Security::SPDPdiscoveredParticipantData::ddsParticipantDataSecure, guid_, and sedp_.

Referenced by shutdown().

 {
   sedp_->write_dcps_participant_dispose(guid_);
 }

◆ write_secure_updates()

void OpenDDS::RTPS::Spdp::write_secure_updates ( )

Write Secured Updated DP QOS

lock_ must be acquired before calling this.

Definition at line 428 of file Spdp.cpp.

References build_local_pdata(), OpenDDS::Security::DPDK_SECURE, OpenDDS::DCPS::GUID_UNKNOWN, initialized_flag_, sedp_, and shutdown_flag_.

Referenced by announce_domain_participant_qos(), remove_agent_info(), update_agent_info(), and use_ice_now().

 {
   if (!initialized_flag_ || shutdown_flag_) {
     return;
   }
 
   const Security::SPDPdiscoveredParticipantData pdata =
     build_local_pdata(false, Security::DPDK_SECURE);
 
   sedp_->write_dcps_participant_secure(pdata, GUID_UNKNOWN);
 }

Friends And Related Function Documentation

◆ ::DDS_TEST

friend class ::DDS_TEST

friend

Definition at line 652 of file Spdp.h.

◆ Sedp

friend class Sedp

friend

Definition at line 381 of file Spdp.h.

Member Data Documentation

◆ available_builtin_endpoints_

BuiltinEndpointSet_t OpenDDS::RTPS::Spdp::available_builtin_endpoints_

private

Definition at line 605 of file Spdp.h.

Referenced by build_local_pdata(), and init().

◆ available_extended_builtin_endpoints_

DDS::Security::ExtendedBuiltinEndpointSet_t OpenDDS::RTPS::Spdp::available_extended_builtin_endpoints_

private

Definition at line 617 of file Spdp.h.

Referenced by build_local_pdata(), and init().

◆ bit_subscriber_

DCPS::RcHandle<DCPS::BitSubscriber> OpenDDS::RTPS::Spdp::bit_subscriber_

private

Definition at line 379 of file Spdp.h.

Referenced by fini_bit(), handle_participant_data(), init_bit(), match_unauthenticated(), OpenDDS::RTPS::Sedp::process_discovered_reader_data(), OpenDDS::RTPS::Sedp::process_discovered_writer_data(), publish_location_update_i(), purge_discovered_participant(), and OpenDDS::RTPS::Sedp::remove_from_bit_i().

◆ config_

DCPS::RcHandle<RtpsDiscoveryConfig> OpenDDS::RTPS::Spdp::config_

private

Definition at line 384 of file Spdp.h.

Referenced by attempt_authentication(), build_local_pdata(), data_received(), handle_handshake_message(), handle_participant_data(), init(), process_handshake_resends(), purge_handshake_resends(), rtps_relay_only_now(), secure_part_user_data(), spdp_rtps_relay_address_change(), update_rtps_relay_application_participant_i(), and use_rtps_relay_now().

◆ crypto_handle_

DDS::Security::ParticipantCryptoHandle OpenDDS::RTPS::Spdp::crypto_handle_

private

Definition at line 625 of file Spdp.h.

Referenced by handle_participant_crypto_tokens(), OpenDDS::RTPS::Sedp::local_has_remote_endpoint_token_i(), OpenDDS::RTPS::Sedp::local_has_remote_participant_token_i(), match_authenticated(), OpenDDS::RTPS::Sedp::remote_has_local_endpoint_token_i(), and OpenDDS::RTPS::Sedp::remote_has_local_participant_token_i().

◆ disco_

RtpsDiscovery* OpenDDS::RTPS::Spdp::disco_

private

Definition at line 383 of file Spdp.h.

Referenced by init_bit().

◆ domain_

const DDS::DomainId_t OpenDDS::RTPS::Spdp::domain_

private

Definition at line 392 of file Spdp.h.

Referenced by build_local_pdata(), data_received(), init_bit(), and match_authenticated().

◆ eh_shutdown_

bool OpenDDS::RTPS::Spdp::eh_shutdown_

private

Definition at line 600 of file Spdp.h.

Referenced by shutdown().

◆ guid_

DCPS::GUID_t OpenDDS::RTPS::Spdp::guid_

private

◆ handshake_deadlines_

TimeQueue OpenDDS::RTPS::Spdp::handshake_deadlines_

private

Definition at line 643 of file Spdp.h.

Referenced by attempt_authentication(), process_handshake_deadlines(), and purge_handshake_deadlines().

◆ handshake_resends_

TimeQueue OpenDDS::RTPS::Spdp::handshake_resends_

private

Definition at line 646 of file Spdp.h.

Referenced by process_handshake_resends(), purge_handshake_resends(), and schedule_handshake_resend().

◆ ice_agent_

DCPS::RcHandle<ICE::Agent> OpenDDS::RTPS::Spdp::ice_agent_

private

Definition at line 634 of file Spdp.h.

Referenced by handle_participant_data(), init_bit(), process_handshake_deadlines(), process_lease_expirations(), process_participant_ice(), shutdown(), start_ice(), stop_ice(), and use_ice_now().

◆ identity_handle_

DDS::Security::IdentityHandle OpenDDS::RTPS::Spdp::identity_handle_

private

Definition at line 623 of file Spdp.h.

Referenced by attempt_authentication(), handle_handshake_message(), match_authenticated(), send_handshake_request(), and Spdp().

◆ identity_status_token_

DDS::Security::IdentityStatusToken OpenDDS::RTPS::Spdp::identity_status_token_

private

Definition at line 628 of file Spdp.h.

Referenced by build_local_pdata(), local_participant_data_as_octets(), and Spdp().

◆ identity_token_

DDS::Security::IdentityToken OpenDDS::RTPS::Spdp::identity_token_

private

Definition at line 627 of file Spdp.h.

Referenced by build_local_pdata(), local_participant_data_as_octets(), and Spdp().

◆ initialized_flag_

AtomicBool OpenDDS::RTPS::Spdp::initialized_flag_

private

Spdp initialized.

Definition at line 598 of file Spdp.h.

Referenced by data_received(), handle_auth_request(), handle_handshake_message(), handle_participant_data(), init_bit(), process_handshake_deadlines(), process_handshake_resends(), process_participant_ice(), and write_secure_updates().

◆ is_application_participant_

bool OpenDDS::RTPS::Spdp::is_application_participant_

private

Definition at line 395 of file Spdp.h.

Referenced by build_local_pdata(), and init().

◆ lease_duration_

DCPS::TimeDuration OpenDDS::RTPS::Spdp::lease_duration_

private

Definition at line 387 of file Spdp.h.

Referenced by build_local_pdata().

◆ lease_expirations_

TimeQueue OpenDDS::RTPS::Spdp::lease_expirations_

private

Definition at line 614 of file Spdp.h.

Referenced by process_lease_expirations(), remove_lease_expiration_i(), and update_lease_expiration_i().

◆ lease_extension_

DCPS::TimeDuration OpenDDS::RTPS::Spdp::lease_extension_

private

Definition at line 388 of file Spdp.h.

Referenced by update_lease_expiration_i().

◆ lock_

◆ min_resend_delay_

const DCPS::TimeDuration OpenDDS::RTPS::Spdp::min_resend_delay_

private

Definition at line 386 of file Spdp.h.

Referenced by validateSequenceNumber().

◆ n_participants_in_authentication_

size_t OpenDDS::RTPS::Spdp::n_participants_in_authentication_

private

Definition at line 648 of file Spdp.h.

Referenced by handle_participant_data(), purge_discovered_participant(), and set_auth_state().

◆ participant_discovered_at_

const DCPS::MonotonicTime_t OpenDDS::RTPS::Spdp::participant_discovered_at_

private

Definition at line 394 of file Spdp.h.

Referenced by build_local_pdata(), and get_participant_discovered_at().

◆ participant_sec_attr_

DDS::Security::ParticipantSecurityAttributes OpenDDS::RTPS::Spdp::participant_sec_attr_

private

Definition at line 632 of file Spdp.h.

Referenced by build_local_pdata(), handle_participant_data(), local_participant_data_as_octets(), match_authenticated(), process_handshake_deadlines(), and Spdp().

◆ participants_

DiscoveredParticipantMap OpenDDS::RTPS::Spdp::participants_

private

Definition at line 382 of file Spdp.h.

Referenced by associated(), OpenDDS::RTPS::Sedp::cleanup_reader_association(), OpenDDS::RTPS::Sedp::cleanup_writer_association(), OpenDDS::RTPS::Sedp::data_acked_i(), get_default_locators(), get_last_recv_locator(), get_participant_data(), get_participant_discovered_at(), get_participant_flags(), handle_auth_request(), OpenDDS::RTPS::Sedp::handle_datareader_crypto_tokens(), OpenDDS::RTPS::Sedp::handle_datawriter_crypto_tokens(), handle_handshake_message(), handle_participant_crypto_tokens(), handle_participant_data(), has_discovered_participant(), ignore_domain_participant(), is_expectant_opendds(), lookup_participant_auth_state(), lookup_participant_crypto_info(), lookup_participant_permissions(), OpenDDS::RTPS::Sedp::match_continue(), process_handshake_deadlines(), process_handshake_resends(), process_lease_expirations(), process_location_updates_i(), process_participant_ice(), purge_discovered_participant(), purge_handshake_deadlines(), purge_handshake_resends(), remove_domain_participant(), rtps_relay_only_now(), OpenDDS::RTPS::Sedp::send_builtin_crypto_tokens(), send_participant_crypto_tokens(), shutdown(), update_rtps_relay_application_participant_i(), use_ice_now(), and use_rtps_relay_now().

◆ permissions_credential_token_

DDS::Security::PermissionsCredentialToken OpenDDS::RTPS::Spdp::permissions_credential_token_

private

Definition at line 630 of file Spdp.h.

Referenced by Spdp().

◆ permissions_handle_

DDS::Security::PermissionsHandle OpenDDS::RTPS::Spdp::permissions_handle_

private

Definition at line 624 of file Spdp.h.

Referenced by Spdp().

◆ permissions_token_

DDS::Security::PermissionsToken OpenDDS::RTPS::Spdp::permissions_token_

private

Definition at line 629 of file Spdp.h.

Referenced by build_local_pdata(), local_participant_data_as_octets(), and Spdp().

◆ qos_

DDS::DomainParticipantQos OpenDDS::RTPS::Spdp::qos_

private

Definition at line 380 of file Spdp.h.

Referenced by build_local_pdata(), get_part_bit_data(), local_participant_data_as_octets(), and update_domain_participant_qos().

◆ quick_resend_ratio_

const double OpenDDS::RTPS::Spdp::quick_resend_ratio_

private

Definition at line 385 of file Spdp.h.

◆ security_config_

Security::SecurityConfig_rch OpenDDS::RTPS::Spdp::security_config_

private

Definition at line 618 of file Spdp.h.

Referenced by attempt_authentication(), handle_handshake_message(), handle_participant_crypto_tokens(), OpenDDS::RTPS::Sedp::local_has_remote_endpoint_token_i(), OpenDDS::RTPS::Sedp::local_has_remote_participant_token_i(), match_authenticated(), purge_discovered_participant(), OpenDDS::RTPS::Sedp::remote_has_local_endpoint_token_i(), OpenDDS::RTPS::Sedp::remote_has_local_participant_token_i(), send_handshake_request(), and Spdp().

◆ security_enabled_

bool OpenDDS::RTPS::Spdp::security_enabled_

private

Definition at line 619 of file Spdp.h.

Referenced by secure_part_user_data().

◆ sedp_

◆ shutdown_cond_

DCPS::ConditionVariable<ACE_Thread_Mutex> OpenDDS::RTPS::Spdp::shutdown_cond_

private

Definition at line 601 of file Spdp.h.

Referenced by shutdown().

◆ shutdown_flag_

AtomicBool OpenDDS::RTPS::Spdp::shutdown_flag_

private

Spdp shutting down.

Definition at line 603 of file Spdp.h.

Referenced by data_received(), handle_auth_request(), handle_handshake_message(), handle_participant_data(), process_handshake_deadlines(), process_handshake_resends(), process_participant_ice(), shutdown(), and write_secure_updates().

◆ stateless_sequence_number_

DCPS::SequenceNumber OpenDDS::RTPS::Spdp::stateless_sequence_number_

private

Definition at line 621 of file Spdp.h.

Referenced by attempt_authentication(), and send_handshake_message().

◆ tport_

DCPS::RcHandle<SpdpTransport> OpenDDS::RTPS::Spdp::tport_

private

◆ type_lookup_service_

XTypes::TypeLookupService_rch OpenDDS::RTPS::Spdp::type_lookup_service_

private

Definition at line 389 of file Spdp.h.

Referenced by init(), and init_bit().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DiscoveredParticipantConstIter

◆ DiscoveredParticipantIter

◆ ParticipantCryptoInfoPair

Constructor & Destructor Documentation

◆ Spdp() [1/2]

◆ Spdp() [2/2]

◆ ~Spdp()

Member Function Documentation

◆ add_publication()

◆ add_subscription()

◆ announce_domain_participant_qos()

◆ append_transport_statistics()

◆ assert_topic()

◆ associated()

◆ attempt_authentication()

◆ available_builtin_endpoints()

◆ available_extended_builtin_endpoints()

◆ build_local_pdata()

◆ config()

◆ crypto_handle()

◆ data_received()

◆ endpoint_manager()

◆ enqueue_location_update_i()

◆ find_topic()

◆ fini_bit()

◆ get_default_locators()

◆ get_domain_id()

◆ get_ice_endpoint_if_added()

◆ get_last_recv_locator()

◆ get_part_bit_data()

◆ get_participant_data() [1/2]

◆ get_participant_data() [2/2]

◆ get_participant_discovered_at() [1/2]

◆ get_participant_discovered_at() [2/2]

◆ get_participant_flags()

◆ get_security_config()

◆ get_sedp_port()

◆ get_spdp_port()

◆ guid()

◆ handle_auth_request()

◆ handle_handshake_message()

◆ handle_participant_crypto_tokens()

◆ handle_participant_data()

◆ has_discovered_participant()

◆ has_domain_participant()

◆ ignore_domain_participant()

◆ ignore_publication()

◆ ignore_subscription()

◆ ignore_topic()

◆ init()

◆ init_bit()

◆ initialized()

◆ is_expectant_opendds()

◆ is_security_enabled()

◆ local_participant_data_as_octets()

◆ lookup_participant_auth_state()

◆ lookup_participant_crypto_info()

◆ lookup_participant_permissions()

◆ match_authenticated()

◆ match_unauthenticated()

◆ OPENDDS_MAP_CMP() [1/2]

◆ OPENDDS_MAP_CMP() [2/2]

◆ OPENDDS_MULTIMAP()

◆ process_handshake_deadlines()

◆ process_handshake_resends()

◆ process_lease_expirations()

◆ process_location_updates_i()

◆ process_participant_ice()

◆ publish_location_update_i()

◆ purge_discovered_participant()

◆ purge_handshake_deadlines()