#include <Sedp.h>

Inheritance diagram for OpenDDS::RTPS::Sedp:

[legend]

Collaboration diagram for OpenDDS::RTPS::Sedp:

[legend]

Classes
class	DiscoveryReader

class	DiscoveryWriter

class	Endpoint

class	LivelinessReader

class	LivelinessWriter

struct	MatchingData

struct	MatchingPair

struct	PublicationAgentInfoListener

class	Reader

class	ReaderAddAssociation

class	ReaderRemoveAssociations

class	SecurityReader

class	SecurityWriter

struct	SubscriptionAgentInfoListener

struct	TypeIdOrigSeqNumber

class	TypeLookupReplyReader

class	TypeLookupReplyWriter

class	TypeLookupRequestReader

class	TypeLookupRequestWriter

class	Writer

class	WriterAddAssociation

class	WriterRemoveAssociations

Public Member Functions
	Sedp (const DCPS::GUID_t &participant_id, Spdp &owner, ACE_Thread_Mutex &lock)

	~Sedp ()

DDS::ReturnCode_t	init (const DCPS::GUID_t &guid, const RtpsDiscovery &disco, DDS::DomainId_t domainId, XTypes::TypeLookupService_rch tls)

DDS::ReturnCode_t	init_security (DDS::Security::IdentityHandle id_handle, DDS::Security::PermissionsHandle perm_handle, DDS::Security::ParticipantCryptoHandle crypto_handle)

void	shutdown ()

DCPS::LocatorSeq	unicast_locators () const

DCPS::LocatorSeq	multicast_locators () const

const DCPS::NetworkAddress &	local_address () const

const DCPS::NetworkAddress &	multicast_group () const

void	associate (DiscoveredParticipant &participant, const DDS::Security::ParticipantSecurityAttributes &participant_sec_attr)

void	generate_remote_matched_crypto_handle (const BuiltinAssociationRecord &record)

bool	ready (const DiscoveredParticipant &participant, const GUID_t &local_id, const GUID_t &remote_id, bool local_tokens_sent) const

void	process_association_records_i (DiscoveredParticipant &participant)

void	generate_remote_matched_crypto_handles (DiscoveredParticipant &participant)

void	disassociate_volatile (DiscoveredParticipant &participant)

void	cleanup_volatile_crypto (const DCPS::GUID_t &remote)

void	associate_volatile (DiscoveredParticipant &participant)

void	remove_remote_crypto_handle (const DCPS::GUID_t &participant, const EntityId_t &entity)

void	send_builtin_crypto_tokens (const DCPS::GUID_t &remoteId)

void	send_builtin_crypto_tokens (const DCPS::GUID_t &dst, const DCPS::GUID_t &src)
	Create and send keys for individual endpoints. More...

void	resend_user_crypto_tokens (const DCPS::GUID_t &remote_participant)

void	disassociate (DiscoveredParticipant &participant)

void	update_locators (const ParticipantData_t &pdata)

DDS::ReturnCode_t	write_stateless_message (const DDS::Security::ParticipantStatelessMessage &msg, const DCPS::GUID_t &reader)

DDS::ReturnCode_t	write_volatile_message (DDS::Security::ParticipantVolatileMessageSecure &msg, const DCPS::GUID_t &reader)

void	write_durable_dcps_participant_secure (const DCPS::GUID_t &reader)

DDS::ReturnCode_t	write_dcps_participant_secure (const Security::SPDPdiscoveredParticipantData &msg, const DCPS::GUID_t &part)

DDS::ReturnCode_t	write_dcps_participant_dispose (const DCPS::GUID_t &part)

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

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

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

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

void	association_complete_i (const DCPS::GUID_t &localId, const DCPS::GUID_t &remoteId)

void	data_acked_i (const DCPS::GUID_t &local_id, const DCPS::GUID_t &remote_id)

void	signal_liveliness (DDS::LivelinessQosPolicyKind kind)

void	signal_liveliness_unsecure (DDS::LivelinessQosPolicyKind kind)

bool	send_type_lookup_request (const XTypes::TypeIdentifierSeq &type_ids, const DCPS::GUID_t &reader, bool is_discovery_protected, bool send_get_types, const SequenceNumber &seq_num)

void	signal_liveliness_secure (DDS::LivelinessQosPolicyKind kind)

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

void	rtps_relay_only_now (bool f)

void	use_rtps_relay_now (bool f)

void	use_ice_now (bool f)

void	rtps_relay_address (const ACE_INET_Addr &address)

void	stun_server_address (const ACE_INET_Addr &address)

DCPS::ReactorTask_rch	reactor_task () const

DCPS::JobQueue_rch	job_queue () const

void	append_transport_statistics (DCPS::TransportStatisticsSequence &seq)

void	ignore (const GUID_t &to_ignore)

bool	ignoring (const GUID_t &guid) const

bool	ignoring (const char *topic_name) 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)

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	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	update_subscription_locators (const GUID_t &subscriptionId, const DCPS::TransportLocatorSeq &transInfo)

Security::HandleRegistry_rch	get_handle_registry () const

RcHandle< DCPS::TransportInst >	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::RcEventHandler
	RcEventHandler ()

ACE_Event_Handler::Reference_Count	add_reference ()

ACE_Event_Handler::Reference_Count	remove_reference ()

Public Member Functions inherited from ACE_Event_Handler
virtual	~ACE_Event_Handler (void)

virtual ACE_HANDLE	get_handle (void) const

virtual void	set_handle (ACE_HANDLE)

virtual int	priority (void) const

virtual void	priority (int priority)

virtual int	handle_input (ACE_HANDLE fd=ACE_INVALID_HANDLE)

virtual int	handle_output (ACE_HANDLE fd=ACE_INVALID_HANDLE)

virtual int	handle_exception (ACE_HANDLE fd=ACE_INVALID_HANDLE)

virtual int	handle_timeout (const ACE_Time_Value &current_time, const void *act=0)

virtual int	handle_exit (ACE_Process *)

virtual int	handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask)

virtual int	handle_signal (int signum, siginfo_t =0, ucontext_t =0)

virtual int	resume_handler (void)

virtual int	handle_qos (ACE_HANDLE=ACE_INVALID_HANDLE)

virtual int	handle_group_qos (ACE_HANDLE=ACE_INVALID_HANDLE)

virtual void	reactor (ACE_Reactor *reactor)

virtual ACE_Reactor *	reactor (void) const

virtual ACE_Reactor_Timer_Interface *	reactor_timer_interface (void) const

Reference_Counting_Policy &	reference_counting_policy (void)

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

Protected Types
typedef MatchingDataMap::iterator	MatchingDataIter

typedef DCPS::PmfSporadicTask< Sedp >	EndpointManagerSporadic

Protected Types inherited from ACE_Event_Handler
typedef ACE_Atomic_Op< ACE_SYNCH_MUTEX, Reference_Count >	Atomic_Reference_Count

Protected Member Functions
DDS::Security::DatawriterCryptoHandle	generate_remote_matched_writer_crypto_handle (const DCPS::GUID_t &writer, const DCPS::GUID_t &reader)

DDS::Security::DatareaderCryptoHandle	generate_remote_matched_reader_crypto_handle (const DCPS::GUID_t &reader, const DCPS::GUID_t &writer, bool relay_only)

void	create_datareader_crypto_tokens (const DDS::Security::DatareaderCryptoHandle &drch, const DDS::Security::DatawriterCryptoHandle &dwch, DDS::Security::DatareaderCryptoTokenSeq &drcts)

void	send_datareader_crypto_tokens (const DCPS::GUID_t &local_reader, const DCPS::GUID_t &remote_writer, const DDS::Security::DatareaderCryptoTokenSeq &drcts)

void	create_and_send_datareader_crypto_tokens (const DDS::Security::DatareaderCryptoHandle &drch, const DCPS::GUID_t &local_reader, const DDS::Security::DatawriterCryptoHandle &dwch, const DCPS::GUID_t &remote_writer)

void	create_datawriter_crypto_tokens (const DDS::Security::DatawriterCryptoHandle &dwch, const DDS::Security::DatareaderCryptoHandle &drch, DDS::Security::DatawriterCryptoTokenSeq &dwcts)

void	send_datawriter_crypto_tokens (const DCPS::GUID_t &local_writer, const DCPS::GUID_t &remote_reader, const DDS::Security::DatawriterCryptoTokenSeq &dwcts)

void	create_and_send_datawriter_crypto_tokens (const DDS::Security::DatawriterCryptoHandle &dwch, const DCPS::GUID_t &local_writer, const DDS::Security::DatareaderCryptoHandle &drch, const DCPS::GUID_t &remote_reader)

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

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

DDS::DomainId_t	get_domain_id () const

void	add_assoc_i (const DCPS::GUID_t &local_guid, const LocalPublication &lpub, const DCPS::GUID_t &remote_guid, const DiscoveredSubscription &dsub)

void	remove_assoc_i (const DCPS::GUID_t &local_guid, const LocalPublication &lpub, const DCPS::GUID_t &remote_guid)

void	add_assoc_i (const DCPS::GUID_t &local_guid, const LocalSubscription &lsub, const DCPS::GUID_t &remote_guid, const DiscoveredPublication &dpub)

void	remove_assoc_i (const DCPS::GUID_t &local_guid, const LocalSubscription &lsub, const DCPS::GUID_t &remote_guid)

void	start_ice (const DCPS::GUID_t &guid, const LocalPublication &lpub)

void	start_ice (const DCPS::GUID_t &guid, const LocalSubscription &lsub)

void	start_ice (const DCPS::GUID_t &guid, const DiscoveredPublication &dpub)

void	start_ice (const DCPS::GUID_t &guid, const DiscoveredSubscription &dsub)

void	stop_ice (const DCPS::GUID_t &guid, const DiscoveredPublication &dpub)

void	stop_ice (const DCPS::GUID_t &guid, const DiscoveredSubscription &dsub)

void	replay_durable_data_for (const DCPS::GUID_t &remote_sub_id)

virtual void	assign_publication_key (GUID_t &rid, const GUID_t &topicId, const DDS::DataWriterQos &)

virtual void	assign_subscription_key (GUID_t &rid, const GUID_t &topicId, const DDS::DataReaderQos &)

virtual void	assign_topic_key (GUID_t &guid)

void	match_endpoints (GUID_t repoId, const DCPS::TopicDetails &td, bool remove=false)

void	remove_assoc (const GUID_t &remove_from, const GUID_t &removing)

typedef	OPENDDS_MAP (MatchingPair, MatchingData) MatchingDataMap

void	match (const GUID_t &writer, const GUID_t &reader)

bool	need_minimal_and_or_complete_types (const XTypes::TypeInformation *type_info, bool &need_minimal, bool &need_complete) const

void	remove_expired_endpoints (const MonotonicTimePoint &)

void	match_continue (const GUID_t &writer, const GUID_t &reader)

void	request_type_objects (const XTypes::TypeInformation *type_info, const MatchingPair &mp, bool is_discovery_protected, bool get_minimal, bool get_complete)

void	get_remote_type_objects (const XTypes::TypeIdentifierWithDependencies &tid_with_deps, MatchingData &md, bool get_minimal, const GUID_t &remote_id, bool is_discovery_protected)

void	match_continue_security_enabled (const GUID_t &writer, const GUID_t &reader, bool call_writer, bool call_reader)

void	remove_from_bit (const DiscoveredPublication &pub)

void	remove_from_bit (const DiscoveredSubscription &sub)

GUID_t	make_topic_guid ()

bool	has_dcps_key (const GUID_t &topicId) const

bool	is_security_enabled ()

void	set_permissions_handle (DDS::Security::PermissionsHandle h)

DDS::Security::PermissionsHandle	get_permissions_handle () const

void	set_access_control (DDS::Security::AccessControl_var acl)

DDS::Security::AccessControl_var	get_access_control () const

void	set_crypto_key_factory (DDS::Security::CryptoKeyFactory_var ckf)

DDS::Security::CryptoKeyFactory_var	get_crypto_key_factory () const

void	set_crypto_key_exchange (DDS::Security::CryptoKeyExchange_var ckf)

DDS::Security::CryptoKeyExchange_var	get_crypto_key_exchange () const

void	set_handle_registry (const Security::HandleRegistry_rch &hr)

	OPENDDS_SET (String) ignored_topics_

	OPENDDS_SET_CMP (GUID_t, GUID_tKeyLessThan) relay_only_readers_

typedef	OPENDDS_MAP_CMP (GUID_t, DDS::Security::DatareaderCryptoTokenSeq, GUID_tKeyLessThan) DatareaderCryptoTokenSeqMap

typedef	OPENDDS_MAP_CMP (GUID_t, DDS::Security::DatawriterCryptoTokenSeq, GUID_tKeyLessThan) DatawriterCryptoTokenSeqMap

void	cleanup_writer_association (DCPS::DataWriterCallbacks_wrch callbacks, const GUID_t &writer, const GUID_t &reader)

void	cleanup_reader_association (DCPS::DataReaderCallbacks_wrch callbacks, const GUID_t &reader, const GUID_t &writer)

Protected Member Functions inherited from ACE_Event_Handler
	ACE_Event_Handler (ACE_Reactor *=0, int priority=ACE_Event_Handler::LO_PRIORITY)

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

Static Protected Member Functions
static DDS::BuiltinTopicKey_t	get_key (const DiscoveredPublication &pub)

static DDS::BuiltinTopicKey_t	get_key (const DiscoveredSubscription &sub)

Protected Attributes
Spdp &	spdp_

ACE_Thread_Mutex &	lock_

GUID_t	participant_id_

RepoIdSet	ignored_guids_

unsigned int	publication_counter_

unsigned int	subscription_counter_

unsigned int	topic_counter_

LocalPublicationMap	local_publications_

LocalSubscriptionMap	local_subscriptions_

DiscoveredPublicationMap	discovered_publications_

DiscoveredSubscriptionMap	discovered_subscriptions_

DCPS::TopicDetailsMap	topics_

TopicNameMap	topic_names_

XTypes::TypeLookupService_rch	type_lookup_service_

OrigSeqNumberMap	orig_seq_numbers_

MatchingDataMap	matching_data_buffer_

RcHandle< EndpointManagerSporadic >	type_lookup_reply_deadline_processor_

TimeDuration	max_type_lookup_service_reply_period_

DCPS::SequenceNumber	type_lookup_service_sequence_number_

const bool	use_xtypes_

const bool	use_xtypes_complete_

DCPS::SequenceNumber	local_participant_automatic_liveliness_sn_

DCPS::SequenceNumber	local_participant_manual_liveliness_sn_

DCPS::SequenceNumber	local_participant_automatic_liveliness_sn_secure_

DCPS::SequenceNumber	local_participant_manual_liveliness_sn_secure_

DDS::Security::ParticipantSecurityAttributes	participant_sec_attr_

DDS::Security::AccessControl_var	access_control_

DDS::Security::CryptoKeyFactory_var	crypto_key_factory_

DDS::Security::CryptoKeyExchange_var	crypto_key_exchange_

Security::HandleRegistry_rch	handle_registry_

DDS::Security::PermissionsHandle	permissions_handle_

DDS::Security::ParticipantCryptoHandle	crypto_handle_

DatareaderCryptoTokenSeqMap	pending_remote_reader_crypto_tokens_

DatawriterCryptoTokenSeqMap	pending_remote_writer_crypto_tokens_

SequenceNumber	participant_secure_sequence_

DiscoveryWriter_rch	publications_writer_

DiscoveryWriter_rch	publications_secure_writer_

DiscoveryWriter_rch	subscriptions_writer_

DiscoveryWriter_rch	subscriptions_secure_writer_

LivelinessWriter_rch	participant_message_writer_

LivelinessWriter_rch	participant_message_secure_writer_

SecurityWriter_rch	participant_stateless_message_writer_

DiscoveryWriter_rch	dcps_participant_secure_writer_

SecurityWriter_rch	participant_volatile_message_secure_writer_

TypeLookupRequestWriter_rch	type_lookup_request_writer_

TypeLookupReplyWriter_rch	type_lookup_reply_writer_

TypeLookupRequestWriter_rch	type_lookup_request_secure_writer_

TypeLookupReplyWriter_rch	type_lookup_reply_secure_writer_

DiscoveryReader_rch	publications_reader_

DiscoveryReader_rch	publications_secure_reader_

DiscoveryReader_rch	subscriptions_reader_

DiscoveryReader_rch	subscriptions_secure_reader_

LivelinessReader_rch	participant_message_reader_

LivelinessReader_rch	participant_message_secure_reader_

SecurityReader_rch	participant_stateless_message_reader_

SecurityReader_rch	participant_volatile_message_secure_reader_

DiscoveryReader_rch	dcps_participant_secure_reader_

TypeLookupRequestReader_rch	type_lookup_request_reader_

TypeLookupReplyReader_rch	type_lookup_reply_reader_

TypeLookupRequestReader_rch	type_lookup_request_secure_reader_

TypeLookupReplyReader_rch	type_lookup_reply_secure_reader_

DCPS::RcHandle< ICE::Agent >	ice_agent_

RcHandle< PublicationAgentInfoListener >	publication_agent_info_listener_

RcHandle< SubscriptionAgentInfoListener >	subscription_agent_info_listener_

Protected Attributes inherited from ACE_Event_Handler
Atomic_Reference_Count	reference_count_

Private Types
typedef DiscoveredSubscriptionMap::iterator	DiscoveredSubscriptionIter

typedef DiscoveredPublicationMap::iterator	DiscoveredPublicationIter

typedef LocalPublicationMap::iterator	LocalPublicationIter

typedef LocalPublicationMap::const_iterator	LocalPublicationCIter

typedef LocalSubscriptionMap::iterator	LocalSubscriptionIter

typedef LocalSubscriptionMap::const_iterator	LocalSubscriptionCIter

typedef DCPS::RcHandle< SecurityWriter >	SecurityWriter_rch

typedef DCPS::RcHandle< LivelinessWriter >	LivelinessWriter_rch

typedef DCPS::RcHandle< DiscoveryWriter >	DiscoveryWriter_rch

typedef DCPS::RcHandle< TypeLookupRequestWriter >	TypeLookupRequestWriter_rch

typedef DCPS::RcHandle< TypeLookupReplyWriter >	TypeLookupReplyWriter_rch

typedef DCPS::RcHandle< Reader >	Reader_rch

typedef DCPS::RcHandle< DiscoveryReader >	DiscoveryReader_rch

typedef DCPS::RcHandle< LivelinessReader >	LivelinessReader_rch

typedef DCPS::RcHandle< SecurityReader >	SecurityReader_rch

typedef DCPS::RcHandle< TypeLookupRequestReader >	TypeLookupRequestReader_rch

typedef DCPS::RcHandle< TypeLookupReplyReader >	TypeLookupReplyReader_rch

Private Member Functions
typedef	OPENDDS_MAP_CMP (GUID_t, DiscoveredSubscription, GUID_tKeyLessThan) DiscoveredSubscriptionMap

typedef	OPENDDS_MAP_CMP (GUID_t, DiscoveredPublication, GUID_tKeyLessThan) DiscoveredPublicationMap

void	populate_origination_locator (const GUID_t &id, DCPS::TransportLocator &tl)

bool	remote_knows_about_local_i (const GUID_t &local, const GUID_t &remote) const

bool	remote_is_authenticated_i (const GUID_t &local, const GUID_t &remote, const DiscoveredParticipant &participant) const

bool	local_has_remote_participant_token_i (const GUID_t &local, const GUID_t &remote) const

bool	remote_has_local_participant_token_i (const GUID_t &local, const GUID_t &remote, const DiscoveredParticipant &participant) const

bool	local_has_remote_endpoint_token_i (const GUID_t &local, const GUID_t &remote) const

bool	remote_has_local_endpoint_token_i (const GUID_t &local, bool local_tokens_sent, const GUID_t &remote) const

void	type_lookup_init (DCPS::ReactorInterceptor_rch reactor_interceptor)

void	type_lookup_fini ()

void	purge_dead_topic (const String &topic_name)

void	cleanup_secure_writer (const GUID_t &publicationId)

void	cleanup_secure_reader (const GUID_t &subscriptionId)

typedef	OPENDDS_MAP_CMP (GUID_t, LocalPublication, GUID_tKeyLessThan) LocalPublicationMap

typedef	OPENDDS_MAP_CMP (GUID_t, LocalSubscription, GUID_tKeyLessThan) LocalSubscriptionMap

typedef	OPENDDS_MAP_CMP (GUID_t, String, GUID_tKeyLessThan) TopicNameMap

typedef	OPENDDS_MAP (SequenceNumber, TypeIdOrigSeqNumber) OrigSeqNumberMap

void	cleanup_type_lookup_data (const DCPS::GUID_t &guid, const XTypes::TypeIdentifier &ti, bool secure)

void	populate_discovered_writer_msg (DCPS::DiscoveredWriterData &dwd, const DCPS::GUID_t &publication_id, const LocalPublication &pub)

void	populate_discovered_reader_msg (DCPS::DiscoveredReaderData &drd, const DCPS::GUID_t &subscription_id, const LocalSubscription &sub)

void	process_discovered_writer_data (DCPS::MessageId message_id, const DCPS::DiscoveredWriterData &wdata, const DCPS::GUID_t &guid, const XTypes::TypeInformation &type_info, bool have_ice_agent_info, const ICE::AgentInfo &ice_agent_info, const DDS::Security::EndpointSecurityInfo *security_info=NULL)

void	data_received (DCPS::MessageId message_id, const DiscoveredPublication &wdata)

void	data_received (DCPS::MessageId message_id, const ParameterListConverter::DiscoveredPublication_SecurityWrapper &wrapper)

void	process_discovered_reader_data (DCPS::MessageId message_id, const DCPS::DiscoveredReaderData &rdata, const DCPS::GUID_t &guid, const XTypes::TypeInformation &type_info, bool have_ice_agent_info, const ICE::AgentInfo &ice_agent_info, const DDS::Security::EndpointSecurityInfo *security_info=NULL)

void	data_received (DCPS::MessageId message_id, const DiscoveredSubscription &rdata)

void	data_received (DCPS::MessageId message_id, const ParameterListConverter::DiscoveredSubscription_SecurityWrapper &wrapper)

void	notify_liveliness (const ParticipantMessageData &pmd)

void	data_received (DCPS::MessageId message_id, const ParticipantMessageData &data)

void	received_participant_message_data_secure (DCPS::MessageId message_id, const ParticipantMessageData &data)

bool	should_drop_stateless_message (const DDS::Security::ParticipantGenericMessage &msg)

bool	should_drop_volatile_message (const DDS::Security::ParticipantGenericMessage &msg)

bool	should_drop_message (const char *unsecure_topic_name)

void	received_stateless_message (DCPS::MessageId message_id, const DDS::Security::ParticipantStatelessMessage &data)

void	received_volatile_message_secure (DCPS::MessageId message_id, const DDS::Security::ParticipantVolatileMessageSecure &data)

void	assign_bit_key (DiscoveredPublication &pub)

void	assign_bit_key (DiscoveredSubscription &sub)

template<typename Map >
void	remove_entities_belonging_to (Map &m, DCPS::GUID_t participant, bool subscription, OPENDDS_VECTOR(typename Map::mapped_type)&to_remove_from_bit)

void	remove_from_bit_i (const DiscoveredPublication &pub)

void	remove_from_bit_i (const DiscoveredSubscription &sub)

virtual DDS::ReturnCode_t	remove_publication_i (const DCPS::GUID_t &publicationId, LocalPublication &pub)

virtual DDS::ReturnCode_t	remove_subscription_i (const DCPS::GUID_t &subscriptionId, LocalSubscription &sub)

virtual bool	shutting_down () const

virtual void	populate_transport_locator_sequence (DCPS::TransportLocatorSeq &tls, DiscoveredSubscriptionIter &iter, const DCPS::GUID_t &reader)

virtual void	populate_transport_locator_sequence (DCPS::TransportLocatorSeq &tls, DiscoveredPublicationIter &iter, const DCPS::GUID_t &writer)

void	write_durable_publication_data (const DCPS::GUID_t &reader, bool secure)

void	write_durable_subscription_data (const DCPS::GUID_t &reader, bool secure)

void	write_durable_participant_message_data (const DCPS::GUID_t &reader)

void	write_durable_participant_message_data_secure (const DCPS::GUID_t &reader)

DDS::ReturnCode_t	add_publication_i (const DCPS::GUID_t &rid, LocalPublication &pub)

DDS::ReturnCode_t	write_publication_data (const DCPS::GUID_t &rid, LocalPublication &pub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_publication_data_secure (const DCPS::GUID_t &rid, LocalPublication &pub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_publication_data_unsecure (const DCPS::GUID_t &rid, LocalPublication &pub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	add_subscription_i (const DCPS::GUID_t &rid, LocalSubscription &sub)

DDS::ReturnCode_t	write_subscription_data (const DCPS::GUID_t &rid, LocalSubscription &sub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_subscription_data_secure (const DCPS::GUID_t &rid, LocalSubscription &sub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_subscription_data_unsecure (const DCPS::GUID_t &rid, LocalSubscription &sub, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_participant_message_data (const DCPS::GUID_t &rid, DCPS::SequenceNumber &sn, const DCPS::GUID_t &reader=GUID_UNKNOWN)

DDS::ReturnCode_t	write_participant_message_data_secure (const DCPS::GUID_t &rid, DCPS::SequenceNumber &sn, const DCPS::GUID_t &reader=GUID_UNKNOWN)

virtual bool	is_expectant_opendds (const GUID_t &endpoint) const

Static Private Member Functions
static void	set_inline_qos (DCPS::TransportLocatorSeq &locators)

Private Attributes
DCPS::TransportInst_rch	transport_inst_

DCPS::TransportConfig_rch	transport_cfg_

DCPS::ReactorTask_rch	reactor_task_

DCPS::JobQueue_rch	job_queue_

DCPS::EventDispatcher_rch	event_dispatcher_

DCPS::RepoIdSet	associated_participants_

Friends
class	Spdp

Additional Inherited Members
Public Types inherited from ACE_Event_Handler
typedef long	Reference_Count

Static Public Member Functions inherited from ACE_Event_Handler
static ACE_THR_FUNC_RETURN	read_adapter (void *event_handler)

static int	register_stdin_handler (ACE_Event_Handler eh, ACE_Reactor reactor, ACE_Thread_Manager *thr_mgr, int flags=THR_DETACHED)

static int	remove_stdin_handler (ACE_Reactor reactor, ACE_Thread_Manager thr_mgr)

Public Attributes inherited from ACE_Event_Handler
	LO_PRIORITY

	HI_PRIORITY

	NULL_MASK

	READ_MASK

	WRITE_MASK

	EXCEPT_MASK

	ACCEPT_MASK

	CONNECT_MASK

	TIMER_MASK

	QOS_MASK

	GROUP_QOS_MASK

	SIGNAL_MASK

	ALL_EVENTS_MASK

	RWE_MASK

	DONT_CALL

	ACE_EVENT_HANDLER_NOT_RESUMED

	ACE_REACTOR_RESUMES_HANDLER

	ACE_APPLICATION_RESUMES_HANDLER

Detailed Description

Definition at line 78 of file Sedp.h.

Member Typedef Documentation

◆ DiscoveredPublicationIter

typedef DiscoveredPublicationMap::iterator OpenDDS::RTPS::Sedp::DiscoveredPublicationIter

private

Definition at line 276 of file Sedp.h.

◆ DiscoveredSubscriptionIter

typedef DiscoveredSubscriptionMap::iterator OpenDDS::RTPS::Sedp::DiscoveredSubscriptionIter

private

Definition at line 272 of file Sedp.h.

◆ DiscoveryReader_rch

typedef DCPS::RcHandle<DiscoveryReader> OpenDDS::RTPS::Sedp::DiscoveryReader_rch

private

Definition at line 656 of file Sedp.h.

◆ DiscoveryWriter_rch

typedef DCPS::RcHandle<DiscoveryWriter> OpenDDS::RTPS::Sedp::DiscoveryWriter_rch

private

Definition at line 561 of file Sedp.h.

◆ EndpointManagerSporadic

typedef DCPS::PmfSporadicTask<Sedp> OpenDDS::RTPS::Sedp::EndpointManagerSporadic

protected

Definition at line 1121 of file Sedp.h.

◆ LivelinessReader_rch

typedef DCPS::RcHandle<LivelinessReader> OpenDDS::RTPS::Sedp::LivelinessReader_rch

private

Definition at line 673 of file Sedp.h.

◆ LivelinessWriter_rch

typedef DCPS::RcHandle<LivelinessWriter> OpenDDS::RTPS::Sedp::LivelinessWriter_rch

private

Definition at line 543 of file Sedp.h.

◆ LocalPublicationCIter

typedef LocalPublicationMap::const_iterator OpenDDS::RTPS::Sedp::LocalPublicationCIter

private

Definition at line 322 of file Sedp.h.

◆ LocalPublicationIter

typedef LocalPublicationMap::iterator OpenDDS::RTPS::Sedp::LocalPublicationIter

private

Definition at line 321 of file Sedp.h.

◆ LocalSubscriptionCIter

typedef LocalSubscriptionMap::const_iterator OpenDDS::RTPS::Sedp::LocalSubscriptionCIter

private

Definition at line 327 of file Sedp.h.

◆ LocalSubscriptionIter

typedef LocalSubscriptionMap::iterator OpenDDS::RTPS::Sedp::LocalSubscriptionIter

private

Definition at line 326 of file Sedp.h.

◆ MatchingDataIter

typedef MatchingDataMap::iterator OpenDDS::RTPS::Sedp::MatchingDataIter

protected

Definition at line 1119 of file Sedp.h.

◆ Reader_rch

typedef DCPS::RcHandle<Reader> OpenDDS::RTPS::Sedp::Reader_rch

private

Definition at line 639 of file Sedp.h.

◆ SecurityReader_rch

typedef DCPS::RcHandle<SecurityReader> OpenDDS::RTPS::Sedp::SecurityReader_rch

private

Definition at line 690 of file Sedp.h.

◆ SecurityWriter_rch

typedef DCPS::RcHandle<SecurityWriter> OpenDDS::RTPS::Sedp::SecurityWriter_rch

private

Definition at line 527 of file Sedp.h.

◆ TypeLookupReplyReader_rch

typedef DCPS::RcHandle<TypeLookupReplyReader> OpenDDS::RTPS::Sedp::TypeLookupReplyReader_rch

private

Definition at line 763 of file Sedp.h.

◆ TypeLookupReplyWriter_rch

typedef DCPS::RcHandle<TypeLookupReplyWriter> OpenDDS::RTPS::Sedp::TypeLookupReplyWriter_rch

private

Definition at line 605 of file Sedp.h.

◆ TypeLookupRequestReader_rch

typedef DCPS::RcHandle<TypeLookupRequestReader> OpenDDS::RTPS::Sedp::TypeLookupRequestReader_rch

private

Definition at line 723 of file Sedp.h.

◆ TypeLookupRequestWriter_rch

typedef DCPS::RcHandle<TypeLookupRequestWriter> OpenDDS::RTPS::Sedp::TypeLookupRequestWriter_rch

private

Definition at line 584 of file Sedp.h.

Constructor & Destructor Documentation

◆ Sedp()

OpenDDS::RTPS::Sedp::Sedp	(	const DCPS::GUID_t &	participant_id,
		Spdp &	owner,
		ACE_Thread_Mutex &	lock
	)

Definition at line 283 of file Sedp.cpp.

   : spdp_(owner)
   , lock_(lock)
   , participant_id_(participant_id)
   , publication_counter_(0)
   , subscription_counter_(0)
   , topic_counter_(0)
   , max_type_lookup_service_reply_period_(0)
   , type_lookup_service_sequence_number_(0)
   , use_xtypes_(true)
   , use_xtypes_complete_(false)
   , local_participant_automatic_liveliness_sn_(DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN())
   , local_participant_manual_liveliness_sn_(DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN())
 #ifdef OPENDDS_SECURITY
   , local_participant_automatic_liveliness_sn_secure_(DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN())
   , local_participant_manual_liveliness_sn_secure_(DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN())
 #endif
 #ifdef OPENDDS_SECURITY
   , permissions_handle_(DDS::HANDLE_NIL)
   , crypto_handle_(DDS::HANDLE_NIL)
 #endif
   , publications_writer_(make_rch<DiscoveryWriter>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , publications_secure_writer_(make_rch<DiscoveryWriter>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER), ref(*this)))
 #endif
   , subscriptions_writer_(make_rch<DiscoveryWriter>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , subscriptions_secure_writer_(make_rch<DiscoveryWriter>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER), ref(*this)))
 #endif
   , participant_message_writer_(make_rch<LivelinessWriter>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , participant_message_secure_writer_(make_rch<LivelinessWriter>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER), ref(*this)))
   , participant_stateless_message_writer_(make_rch<SecurityWriter>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER), ref(*this)))
   , dcps_participant_secure_writer_(make_rch<DiscoveryWriter>(
       make_id(participant_id, ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER), ref(*this), 2))
   , participant_volatile_message_secure_writer_(make_rch<SecurityWriter>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER), ref(*this)))
 #endif
   , type_lookup_request_writer_(make_rch<TypeLookupRequestWriter>(
       make_id(participant_id, ENTITYID_TL_SVC_REQ_WRITER), ref(*this)))
   , type_lookup_reply_writer_(make_rch<TypeLookupReplyWriter>(
       make_id(participant_id, ENTITYID_TL_SVC_REPLY_WRITER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , type_lookup_request_secure_writer_(make_rch<TypeLookupRequestWriter>(
       make_id(participant_id, ENTITYID_TL_SVC_REQ_WRITER_SECURE), ref(*this)))
   , type_lookup_reply_secure_writer_(make_rch<TypeLookupReplyWriter>(
       make_id(participant_id, ENTITYID_TL_SVC_REPLY_WRITER_SECURE), ref(*this)))
 #endif
   , publications_reader_(make_rch<DiscoveryReader>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , publications_secure_reader_(make_rch<DiscoveryReader>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER), ref(*this)))
 #endif
   , subscriptions_reader_(make_rch<DiscoveryReader>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , subscriptions_secure_reader_(make_rch<DiscoveryReader>(
       make_id(participant_id, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER), ref(*this)))
 #endif
   , participant_message_reader_(make_rch<LivelinessReader>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , participant_message_secure_reader_(make_rch<LivelinessReader>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER), ref(*this)))
   , participant_stateless_message_reader_(make_rch<SecurityReader>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER), ref(*this)))
   , participant_volatile_message_secure_reader_(make_rch<SecurityReader>(
       make_id(participant_id, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER), ref(*this)))
   , dcps_participant_secure_reader_(make_rch<DiscoveryReader>(
       make_id(participant_id, ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER), ref(*this)))
 #endif
   , type_lookup_request_reader_(make_rch<TypeLookupRequestReader>(
       make_id(participant_id, ENTITYID_TL_SVC_REQ_READER), ref(*this)))
   , type_lookup_reply_reader_(make_rch<TypeLookupReplyReader>(
       make_id(participant_id, ENTITYID_TL_SVC_REPLY_READER), ref(*this)))
 #ifdef OPENDDS_SECURITY
   , type_lookup_request_secure_reader_(make_rch<TypeLookupRequestReader>(
       make_id(participant_id, ENTITYID_TL_SVC_REQ_READER_SECURE), ref(*this)))
   , type_lookup_reply_secure_reader_(make_rch<TypeLookupReplyReader>(
       make_id(participant_id, ENTITYID_TL_SVC_REPLY_READER_SECURE), ref(*this)))
   , ice_agent_(ICE::Agent::instance())
   , publication_agent_info_listener_(DCPS::make_rch<PublicationAgentInfoListener>(ref(*this)))
   , subscription_agent_info_listener_(DCPS::make_rch<SubscriptionAgentInfoListener>(ref(*this)))
 #endif // OPENDDS_SECURITY
 {}

◆ ~Sedp()

OpenDDS::RTPS::Sedp::~Sedp ( )

Definition at line 877 of file Sedp.cpp.

References cleanup_secure_reader(), cleanup_secure_writer(), dcps_participant_secure_reader_, dcps_participant_secure_writer_, OpenDDS::Security::SecurityConfig::erase_handle_registry(), OpenDDS::RTPS::Spdp::get_security_config(), job_queue_, participant_id_, participant_message_secure_reader_, participant_message_secure_writer_, participant_volatile_message_secure_reader_, participant_volatile_message_secure_writer_, publications_secure_reader_, publications_secure_writer_, reactor_task_, OpenDDS::DCPS::RcHandle< T >::reset(), spdp_, OpenDDS::DCPS::static_rchandle_cast(), subscriptions_secure_reader_, subscriptions_secure_writer_, TheTransportRegistry, transport_cfg_, transport_inst_, and type_lookup_fini().

 {
   type_lookup_fini();
 
 #ifdef OPENDDS_SECURITY
   using namespace OpenDDS::Security;
   using namespace DDS::Security;
 
   SecurityException ex = {"", 0, 0};
 
   cleanup_secure_writer(participant_volatile_message_secure_writer_->get_guid());
   cleanup_secure_reader(participant_volatile_message_secure_reader_->get_guid());
   cleanup_secure_writer(participant_message_secure_writer_->get_guid());
   cleanup_secure_reader(participant_message_secure_reader_->get_guid());
   cleanup_secure_writer(publications_secure_writer_->get_guid());
   cleanup_secure_reader(publications_secure_reader_->get_guid());
   cleanup_secure_writer(subscriptions_secure_writer_->get_guid());
   cleanup_secure_reader(subscriptions_secure_reader_->get_guid());
   cleanup_secure_writer(dcps_participant_secure_writer_->get_guid());
   cleanup_secure_reader(dcps_participant_secure_reader_->get_guid());
   if (spdp_.get_security_config()) {
     spdp_.get_security_config()->erase_handle_registry(participant_id_);
   }
 #endif
 
   job_queue_.reset();
   reactor_task_.reset();
   DCPS::RtpsUdpInst_rch rtps_inst =
     DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   rtps_inst->opendds_discovery_default_listener_.reset();
   TheTransportRegistry->remove_config(transport_cfg_);
   TheTransportRegistry->remove_inst(transport_inst_);
 }

Member Function Documentation

◆ add_assoc_i() [1/2]

void OpenDDS::RTPS::Sedp::add_assoc_i	(	const DCPS::GUID_t &	local_guid,
		const LocalPublication &	lpub,
		const DCPS::GUID_t &	remote_guid,
		const DiscoveredSubscription &	dsub
	)

protected

Definition at line 5616 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredSubscription::have_ice_agent_info_, ice_agent_, OpenDDS::RTPS::DiscoveredSubscription::ice_agent_info_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), and OpenDDS::RTPS::LocalPublication::publication_.

Referenced by match_continue(), and OpenDDS::RTPS::Sedp::SubscriptionAgentInfoListener::SubscriptionAgentInfoListener().

                                                                                      {
 #ifdef OPENDDS_SECURITY
   DCPS::DataWriterCallbacks_rch pl = lpub.publication_.lock();
   if (pl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
     if (endpoint && dsub.have_ice_agent_info_) {
       ice_agent_->start_ice(endpoint, local_guid, remote_guid, dsub.ice_agent_info_);
     }
   }
 #else
   ACE_UNUSED_ARG(local_guid);
   ACE_UNUSED_ARG(lpub);
   ACE_UNUSED_ARG(remote_guid);
   ACE_UNUSED_ARG(dsub);
 #endif
 }

◆ add_assoc_i() [2/2]

void OpenDDS::RTPS::Sedp::add_assoc_i	(	const DCPS::GUID_t &	local_guid,
		const LocalSubscription &	lsub,
		const DCPS::GUID_t &	remote_guid,
		const DiscoveredPublication &	dpub
	)

protected

Definition at line 5653 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredPublication::have_ice_agent_info_, ice_agent_, OpenDDS::RTPS::DiscoveredPublication::ice_agent_info_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), and OpenDDS::RTPS::LocalSubscription::subscription_.

                                                                                     {
 #ifdef OPENDDS_SECURITY
   DCPS::DataReaderCallbacks_rch sl = lsub.subscription_.lock();
   if (sl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
     if (endpoint && dpub.have_ice_agent_info_) {
       ice_agent_->start_ice(endpoint, local_guid, remote_guid, dpub.ice_agent_info_);
     }
   }
 #else
   ACE_UNUSED_ARG(local_guid);
   ACE_UNUSED_ARG(lsub);
   ACE_UNUSED_ARG(remote_guid);
   ACE_UNUSED_ARG(dpub);
 #endif
 }

◆ add_publication()

GUID_t OpenDDS::RTPS::Sedp::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
	)

Definition at line 6122 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_GUARD_RETURN, ACE_TEXT(), OpenDDS::DCPS::TopicDetails::add_local_publication(), add_publication_i(), assign_publication_key(), DDS::Security::SecurityException::code, crypto_handle_, OpenDDS::DCPS::DCPS_debug_level, get_access_control(), get_crypto_key_factory(), get_domain_id(), get_handle_registry(), get_permissions_handle(), DDS::HANDLE_NIL, OpenDDS::Security::HandleRegistry::insert_local_datawriter_crypto_handle(), DDS::Security::EndpointSecurityAttributes::is_payload_protected, is_security_enabled(), DDS::Security::EndpointSecurityAttributes::is_submessage_protected, DDS::Security::TopicSecurityAttributes::is_write_protected, LM_DEBUG, LM_ERROR, LM_WARNING, local_publications_, OpenDDS::DCPS::TransportClient::lock_, match_endpoints(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, participant_id_, DDS::PublisherQos::partition, OpenDDS::RTPS::LocalPublication::publication_, OpenDDS::RTPS::LocalPublication::publisher_qos_, OpenDDS::RTPS::LocalPublication::qos_, DDS::RETCODE_OK, OpenDDS::RTPS::LocalEntity::security_attribs_, OpenDDS::RTPS::LocalEntity::topic_id_, topic_names_, topics_, OpenDDS::RTPS::LocalEntity::trans_info_, OpenDDS::RTPS::LocalEntity::type_info_, and write_publication_data().

Referenced by ignoring().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, GUID_t());
 
   GUID_t rid = participant_id_;
   assign_publication_key(rid, topicId, qos);
   LocalPublication& pb = local_publications_[rid];
   pb.topic_id_ = topicId;
   pb.publication_ = publication;
   pb.qos_ = qos;
   pb.trans_info_ = transInfo;
   pb.publisher_qos_ = publisherQos;
   pb.type_info_ = type_info;
   const String& topic_name = topic_names_[topicId];
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled()) {
     DDS::Security::SecurityException ex;
 
     DDS::Security::TopicSecurityAttributes topic_sec_attr;
     DDS::Security::PermissionsHandle permh = get_permissions_handle();
     if (!get_access_control()->get_topic_sec_attributes(permh, topic_name.data(), topic_sec_attr, ex)) {
       ACE_ERROR((LM_ERROR,
         ACE_TEXT("(%P|%t) ERROR: ")
         ACE_TEXT("Sedp::add_publication: ")
         ACE_TEXT("Unable to get security attributes for topic '%C'. SecurityException[%d.%d]: %C\n"),
           topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
       return GUID_t();
     }
 
     if (topic_sec_attr.is_write_protected) {
       if (!get_access_control()->check_create_datawriter(
             permh, get_domain_id(), topic_name.data(), qos,
             publisherQos.partition, DDS::Security::DataTagQosPolicy(), ex)) {
         ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: ")
           ACE_TEXT("Sedp::add_publication: ")
           ACE_TEXT("Permissions check failed for local datawriter on topic '%C'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), topic_name.data(),
             ex.code, ex.minor_code, ex.message.in()));
         return GUID_t();
       }
     }
 
     if (!get_access_control()->get_datawriter_sec_attributes(permh, topic_name.data(),
         publisherQos.partition, DDS::Security::DataTagQosPolicy(), pb.security_attribs_, ex)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
                  ACE_TEXT("Sedp::add_publication: ")
                  ACE_TEXT("Unable to get security attributes for local datawriter. ")
                  ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                  ex.code, ex.minor_code, ex.message.in()));
       return GUID_t();
     }
 
     if (pb.security_attribs_.is_submessage_protected || pb.security_attribs_.is_payload_protected) {
       const DDS::Security::DatawriterCryptoHandle handle =
         get_crypto_key_factory()->register_local_datawriter(
           crypto_handle_, DDS::PropertySeq(), pb.security_attribs_, ex);
       if (handle == DDS::HANDLE_NIL) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
                    ACE_TEXT("Sedp::add_publication: ")
                    ACE_TEXT("Unable to get local datawriter crypto handle. ")
                    ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                    ex.code, ex.minor_code, ex.message.in()));
       }
 
       get_handle_registry()->insert_local_datawriter_crypto_handle(rid, handle, pb.security_attribs_);
     }
   }
 #endif
 
   DCPS::TopicDetails& td = topics_[topic_name];
   td.add_local_publication(rid);
 
   if (DDS::RETCODE_OK != add_publication_i(rid, pb)) {
     return GUID_t();
   }
 
   if (DDS::RETCODE_OK != write_publication_data(rid, pb)) {
     return GUID_t();
   }
 
   if (DCPS_debug_level > 3) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::add_publication: ")
                ACE_TEXT("calling match_endpoints\n")));
   }
   match_endpoints(rid, td);
 
   return rid;
 }

◆ add_publication_i()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::add_publication_i	(	const DCPS::GUID_t &	rid,
		LocalPublication &	pub
	)

private

Definition at line 4806 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::config(), OpenDDS::RTPS::Spdp::get_participant_discovered_at(), OpenDDS::RTPS::LocalEntity::have_ice_agent_info, ice_agent_, OpenDDS::RTPS::LocalEntity::ice_agent_info, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalEntity::participant_discovered_at_, OpenDDS::RTPS::LocalPublication::publication_, publication_agent_info_listener_, DDS::RETCODE_OK, spdp_, start_ice(), and OpenDDS::RTPS::LocalEntity::transport_context_.

Referenced by add_publication().

 {
   pub.participant_discovered_at_ = spdp_.get_participant_discovered_at();
   pub.transport_context_ = spdp_.config()->participant_flags();
 #ifdef OPENDDS_SECURITY
   DCPS::DataWriterCallbacks_rch pl = pub.publication_.lock();
   if (pl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
     if (endpoint) {
       pub.have_ice_agent_info = true;
       pub.ice_agent_info = ice_agent_->get_local_agent_info(endpoint);
       ice_agent_->add_local_agent_info_listener(endpoint, rid, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(publication_agent_info_listener_));
       start_ice(rid, pub);
     }
   }
 #else
   ACE_UNUSED_ARG(rid);
   ACE_UNUSED_ARG(pub);
 #endif
   return DDS::RETCODE_OK;
 }

◆ add_subscription()

GUID_t OpenDDS::RTPS::Sedp::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
	)

Definition at line 6261 of file Sedp.cpp.

Referenced by ignoring().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, GUID_t());
 
   GUID_t rid = participant_id_;
   assign_subscription_key(rid, topicId, qos);
   LocalSubscription& sb = local_subscriptions_[rid];
   sb.topic_id_ = topicId;
   sb.subscription_ = subscription;
   sb.qos_ = qos;
   sb.trans_info_ = transInfo;
   sb.subscriber_qos_ = subscriberQos;
   sb.filterProperties.filterClassName = filterClassName;
   sb.filterProperties.filterExpression = filterExpr;
   sb.filterProperties.expressionParameters = params;
   sb.type_info_ = type_info;
   const String& topic_name = topic_names_[topicId];
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled()) {
     DDS::Security::SecurityException ex;
 
     DDS::Security::TopicSecurityAttributes topic_sec_attr;
     if (!get_access_control()->get_topic_sec_attributes(
         get_permissions_handle(), topic_name.data(), topic_sec_attr, ex)) {
       ACE_ERROR((LM_ERROR,
         ACE_TEXT("(%P|%t) ERROR: ")
         ACE_TEXT("Sedp::add_subscription: ")
         ACE_TEXT("Unable to get security attributes for topic '%C'. ")
         ACE_TEXT("SecurityException[%d.%d]: %C\n"),
           topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
       return GUID_t();
     }
 
     if (topic_sec_attr.is_read_protected) {
       if (!get_access_control()->check_create_datareader(
         get_permissions_handle(), get_domain_id(), topic_name.data(), qos,
         subscriberQos.partition, DDS::Security::DataTagQosPolicy(), ex)) {
         ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: ")
           ACE_TEXT("Sedp::add_subscription: ")
           ACE_TEXT("Permissions check failed for local datareader on topic '%C'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), topic_name.data(),
             ex.code, ex.minor_code, ex.message.in()));
         return GUID_t();
       }
     }
 
     if (!get_access_control()->get_datareader_sec_attributes(get_permissions_handle(), topic_name.data(),
         subscriberQos.partition, DDS::Security::DataTagQosPolicy(), sb.security_attribs_, ex)) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
                  ACE_TEXT("Sedp::add_subscription: ")
                  ACE_TEXT("Unable to get security attributes for local datareader. ")
                  ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                  ex.code, ex.minor_code, ex.message.in()));
       return GUID_t();
     }
 
     if (sb.security_attribs_.is_submessage_protected || sb.security_attribs_.is_payload_protected) {
       DDS::Security::DatareaderCryptoHandle handle =
         get_crypto_key_factory()->register_local_datareader(
           crypto_handle_, DDS::PropertySeq(), sb.security_attribs_, ex);
       if (handle == DDS::HANDLE_NIL) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
                    ACE_TEXT("Sedp::add_subscription: ")
                    ACE_TEXT("Unable to get local datareader crypto handle. ")
                    ACE_TEXT("Security Exception[%d.%d]: %C\n"),
                    ex.code, ex.minor_code, ex.message.in()));
       }
 
       get_handle_registry()->insert_local_datareader_crypto_handle(rid, handle, sb.security_attribs_);
     }
   }
 #endif
 
   DCPS::TopicDetails& td = topics_[topic_name];
   td.add_local_subscription(rid);
 
   if (DDS::RETCODE_OK != add_subscription_i(rid, sb)) {
     return GUID_t();
   }
 
   if (DDS::RETCODE_OK != write_subscription_data(rid, sb)) {
     return GUID_t();
   }
 
   if (DCPS_debug_level > 3) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::add_subscription: ")
                ACE_TEXT("calling match_endpoints\n")));
   }
   match_endpoints(rid, td);
 
   return rid;
 }

◆ add_subscription_i()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::add_subscription_i	(	const DCPS::GUID_t &	rid,
		LocalSubscription &	sub
	)

private

Definition at line 4958 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::config(), OpenDDS::RTPS::Spdp::get_participant_discovered_at(), OpenDDS::RTPS::LocalEntity::have_ice_agent_info, ice_agent_, OpenDDS::RTPS::LocalEntity::ice_agent_info, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalEntity::participant_discovered_at_, DDS::RETCODE_OK, spdp_, start_ice(), OpenDDS::RTPS::LocalSubscription::subscription_, subscription_agent_info_listener_, and OpenDDS::RTPS::LocalEntity::transport_context_.

Referenced by add_subscription().

 {
   sub.participant_discovered_at_ = spdp_.get_participant_discovered_at();
   sub.transport_context_ = spdp_.config()->participant_flags();
 #ifdef OPENDDS_SECURITY
   DCPS::DataReaderCallbacks_rch sl = sub.subscription_.lock();
   if (sl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
     if (endpoint) {
       sub.have_ice_agent_info = true;
       sub.ice_agent_info = ice_agent_->get_local_agent_info(endpoint);
       ice_agent_->add_local_agent_info_listener(endpoint, rid, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(subscription_agent_info_listener_));
       start_ice(rid, sub);
     }
   }
 #else
   ACE_UNUSED_ARG(rid);
   ACE_UNUSED_ARG(sub);
 #endif
   return DDS::RETCODE_OK;
 }

◆ append_transport_statistics()

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

Definition at line 5977 of file Sedp.cpp.

References OpenDDS::DCPS::TransportInst::append_transport_statistics(), and transport_inst_.

Referenced by job_queue().

 {
   transport_inst_->append_transport_statistics(seq);
 }

◆ assert_topic()

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

Definition at line 6060 of file Sedp.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::CONFLICTING_TYPENAME, OpenDDS::DCPS::CREATED, OpenDDS::DCPS::FOUND, OpenDDS::DCPS::TopicDetails::init(), OpenDDS::DCPS::INTERNAL_ERROR, OpenDDS::DCPS::TransportClient::lock_, make_topic_guid(), OpenDDS::DCPS::TopicDetails::set_local(), topic_names_, and topics_.

Referenced by OpenDDS::RTPS::Spdp::assert_topic(), and ignoring().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, DCPS::INTERNAL_ERROR);
   DCPS::TopicDetailsMap::iterator iter = topics_.find(topicName);
   if (iter != topics_.end()) {
     if (iter->second.local_is_set() && iter->second.local_data_type_name() != dataTypeName) {
       return DCPS::CONFLICTING_TYPENAME;
     }
     topicId = iter->second.topic_id();
     iter->second.set_local(dataTypeName, qos, hasDcpsKey, topic_callbacks);
     return DCPS::FOUND;
   }
 
   DCPS::TopicDetails& td = topics_[topicName];
   topicId = make_topic_guid();
   td.init(topicName, topicId);
   topic_names_[topicId] = topicName;
   td.set_local(dataTypeName, qos, hasDcpsKey, topic_callbacks);
 
   return DCPS::CREATED;
 }

◆ assign_bit_key() [1/2]

void OpenDDS::RTPS::Sedp::assign_bit_key ( DiscoveredPublication & pub )

private

Definition at line 954 of file Sedp.cpp.

References OpenDDS::DCPS::DiscoveredWriterData::ddsPublicationData, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::guid_to_bit_key(), OpenDDS::DCPS::make_id(), OpenDDS::DCPS::WriterProxy_t::remoteWriterGuid, OpenDDS::RTPS::DiscoveredPublication::writer_data_, and OpenDDS::DCPS::DiscoveredWriterData::writerProxy.

Referenced by process_discovered_reader_data(), and process_discovered_writer_data().

 {
   const DDS::BuiltinTopicKey_t key = guid_to_bit_key(pub.writer_data_.writerProxy.remoteWriterGuid);
   pub.writer_data_.ddsPublicationData.key = key;
   pub.writer_data_.ddsPublicationData.participant_key = guid_to_bit_key(make_id(pub.writer_data_.writerProxy.remoteWriterGuid, ENTITYID_PARTICIPANT));
 }

◆ assign_bit_key() [2/2]

void OpenDDS::RTPS::Sedp::assign_bit_key ( DiscoveredSubscription & sub )

private

Definition at line 962 of file Sedp.cpp.

References OpenDDS::DCPS::DiscoveredReaderData::ddsSubscriptionData, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::guid_to_bit_key(), OpenDDS::DCPS::make_id(), OpenDDS::RTPS::DiscoveredSubscription::reader_data_, OpenDDS::DCPS::DiscoveredReaderData::readerProxy, and OpenDDS::DCPS::ReaderProxy_t::remoteReaderGuid.

 {
   const DDS::BuiltinTopicKey_t key = guid_to_bit_key(sub.reader_data_.readerProxy.remoteReaderGuid);
   sub.reader_data_.ddsSubscriptionData.key = key;
   sub.reader_data_.ddsSubscriptionData.participant_key = guid_to_bit_key(make_id(sub.reader_data_.readerProxy.remoteReaderGuid, ENTITYID_PARTICIPANT));
 }

◆ assign_publication_key()

virtual void OpenDDS::RTPS::Sedp::assign_publication_key	(	GUID_t &	rid,
		const GUID_t &	topicId,
		const DDS::DataWriterQos &
	)

inlineprotectedvirtual

Definition at line 1018 of file Sedp.h.

References OpenDDS::DCPS::assign(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::EntityId_t::entityKey, OpenDDS::DCPS::EntityId_t::entityKind, OpenDDS::DCPS::ENTITYKIND_USER_WRITER_NO_KEY, OpenDDS::DCPS::ENTITYKIND_USER_WRITER_WITH_KEY, has_dcps_key(), and publication_counter_.

Referenced by add_publication().

   {
     rid.entityId.entityKind =
       has_dcps_key(topicId)
       ? DCPS::ENTITYKIND_USER_WRITER_WITH_KEY
       : DCPS::ENTITYKIND_USER_WRITER_NO_KEY;
     assign(rid.entityId.entityKey, publication_counter_++);
   }

◆ assign_subscription_key()

virtual void OpenDDS::RTPS::Sedp::assign_subscription_key	(	GUID_t &	rid,
		const GUID_t &	topicId,
		const DDS::DataReaderQos &
	)

inlineprotectedvirtual

Definition at line 1028 of file Sedp.h.

References OpenDDS::DCPS::assign(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::EntityId_t::entityKey, OpenDDS::DCPS::EntityId_t::entityKind, OpenDDS::DCPS::ENTITYKIND_USER_READER_NO_KEY, OpenDDS::DCPS::ENTITYKIND_USER_READER_WITH_KEY, has_dcps_key(), and subscription_counter_.

Referenced by add_subscription().

   {
     rid.entityId.entityKind =
       has_dcps_key(topicId)
       ? DCPS::ENTITYKIND_USER_READER_WITH_KEY
       : DCPS::ENTITYKIND_USER_READER_NO_KEY;
     assign(rid.entityId.entityKey, subscription_counter_++);
   }

◆ assign_topic_key()

virtual void OpenDDS::RTPS::Sedp::assign_topic_key ( GUID_t & guid )

inlineprotectedvirtual

Definition at line 1038 of file Sedp.h.

References ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::assign(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::EntityId_t::entityKey, LM_ERROR, match_endpoints(), remove_assoc(), and topic_counter_.

Referenced by make_topic_guid().

   {
     assign(guid.entityId.entityKey, topic_counter_++);
 
     if (topic_counter_ == 0x1000000) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::assign_topic_key: ")
                  ACE_TEXT("Exceeded Maximum number of topic entity keys!")
                  ACE_TEXT("Next key will be a duplicate!\n")));
       topic_counter_ = 0;
     }
   }

◆ associate()

void OpenDDS::RTPS::Sedp::associate	(	DiscoveredParticipant &	participant,
		const DDS::Security::ParticipantSecurityAttributes &	participant_sec_attr
	)

Definition at line 1044 of file Sedp.cpp.

 {
   const BuiltinEndpointSet_t local_available = spdp_.available_builtin_endpoints();
   const BuiltinEndpointSet_t remote_available = participant.pdata_.participantProxy.availableBuiltinEndpoints;
   const BuiltinEndpointQos_t& beq = participant.pdata_.participantProxy.builtinEndpointQos;
 
   // See RTPS v2.1 section 8.5.5.1
   if ((local_available & DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR) &&
       (remote_available & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER)) {
     BuiltinAssociationRecord record(publications_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER),
                                     AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR) &&
       (remote_available & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER)) {
     BuiltinAssociationRecord record(subscriptions_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER),
                                     AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER) &&
       (remote_available & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER)) {
     BuiltinAssociationRecord record(participant_message_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER),
                                     AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
 
   if ((local_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER) &&
       (remote_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER)) {
     BuiltinAssociationRecord record(type_lookup_request_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REQ_WRITER),
                                     AC_REMOTE_RELIABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER) &&
       (remote_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER)) {
     BuiltinAssociationRecord record(type_lookup_request_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REQ_READER),
                                     AC_REMOTE_RELIABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER) &&
       (remote_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER)) {
     BuiltinAssociationRecord record(type_lookup_reply_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REPLY_WRITER),
                                     AC_REMOTE_RELIABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER) &&
       (remote_available & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER)) {
     BuiltinAssociationRecord record(type_lookup_reply_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REPLY_READER),
                                     AC_REMOTE_RELIABLE);
     participant.builtin_pending_records_.push_back(record);
   }
 
   if ((local_available & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER) &&
       (remote_available & DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR)) {
     BuiltinAssociationRecord record(publications_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER),
                                     AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER) &&
       (remote_available & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR)) {
     BuiltinAssociationRecord record(subscriptions_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER),
                                     AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER) &&
       (remote_available & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER)) {
     BuiltinAssociationRecord record(participant_message_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER),
                                     ((beq & BEST_EFFORT_PARTICIPANT_MESSAGE_DATA_READER) ? AC_EMPTY : AC_REMOTE_RELIABLE) | AC_REMOTE_DURABLE);
     participant.builtin_pending_records_.push_back(record);
   }
 
   //FUTURE: if/when topic propagation is supported, add it here
 
 #ifdef OPENDDS_SECURITY
   if (spdp_.is_security_enabled()) {
     using namespace DDS::Security;
 
     const ExtendedBuiltinEndpointSet_t local_available_extended = spdp_.available_extended_builtin_endpoints();
     const ExtendedBuiltinEndpointSet_t remote_available_extended = participant.pdata_.participantProxy.availableExtendedBuiltinEndpoints;
 
     if ((local_available & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER) &&
         (remote_available & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER)) {
       BuiltinAssociationRecord record(participant_stateless_message_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER),
                                       AC_EMPTY);
       participant.builtin_pending_records_.push_back(record);
     }
 
     if ((local_available & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER) &&
         (remote_available & BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER)) {
       BuiltinAssociationRecord record(participant_stateless_message_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER),
                                       AC_EMPTY);
       participant.builtin_pending_records_.push_back(record);
     }
 
     if ((local_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER) &&
         (remote_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER)) {
       BuiltinAssociationRecord record(participant_volatile_message_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE);
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER) &&
         (remote_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER)) {
       BuiltinAssociationRecord record(participant_volatile_message_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE);
       participant.builtin_pending_records_.push_back(record);
     }
 
     if ((local_available & BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) &&
         (remote_available & BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER)) {
       BuiltinAssociationRecord record(participant_message_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_liveliness_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SPDP_BUILTIN_PARTICIPANT_SECURE_READER) &&
         (remote_available & SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER)) {
       BuiltinAssociationRecord record(dcps_participant_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) &&
         (remote_available & SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER)) {
       BuiltinAssociationRecord record(publications_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) &&
         (remote_available & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER)) {
       BuiltinAssociationRecord record(subscriptions_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
 
     if ((local_available_extended & TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE) &&
         (remote_available_extended & TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE)) {
       BuiltinAssociationRecord record(type_lookup_request_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REQ_WRITER_SECURE),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available_extended & TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE) &&
         (remote_available_extended & TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE)) {
       BuiltinAssociationRecord record(type_lookup_request_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REQ_READER_SECURE),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available_extended & TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE) &&
         (remote_available_extended & TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE)) {
       BuiltinAssociationRecord record(type_lookup_reply_secure_reader_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REPLY_WRITER_SECURE),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available_extended & TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE) &&
         (remote_available_extended & TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE)) {
       BuiltinAssociationRecord record(type_lookup_reply_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_TL_SVC_REPLY_READER_SECURE),
                                       AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
 
     if ((local_available & BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER) &&
         (remote_available & BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER)) {
       BuiltinAssociationRecord record(participant_message_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER),
                                       ((beq & BEST_EFFORT_PARTICIPANT_MESSAGE_DATA_READER) ? AC_EMPTY : AC_REMOTE_RELIABLE) | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_liveliness_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER) &&
         (remote_available & SPDP_BUILTIN_PARTICIPANT_SECURE_READER)) {
       BuiltinAssociationRecord record(dcps_participant_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER) &&
         (remote_available & SEDP_BUILTIN_PUBLICATIONS_SECURE_READER)) {
       BuiltinAssociationRecord record(publications_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
     if ((local_available & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER) &&
         (remote_available & SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER)) {
       BuiltinAssociationRecord record(subscriptions_secure_writer_,
                                       make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER),
                                       AC_REMOTE_RELIABLE | AC_REMOTE_DURABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE | (participant_sec_attr.is_discovery_protected ? AC_SEND_LOCAL_TOKEN : AC_EMPTY));
       participant.builtin_pending_records_.push_back(record);
     }
   }
 #endif
 
   if (spdp_.shutting_down()) { return; }
 
   associated_participants_.insert(make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_PARTICIPANT));
 
   process_association_records_i(participant);
 }

◆ associate_volatile()

void OpenDDS::RTPS::Sedp::associate_volatile ( DiscoveredParticipant & participant )

Definition at line 1385 of file Sedp.cpp.

References OpenDDS::RTPS::AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE, OpenDDS::RTPS::AC_REMOTE_RELIABLE, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::ParticipantProxy_t::availableBuiltinEndpoints, DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER, DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER, OpenDDS::RTPS::DiscoveredParticipant::builtin_pending_records_, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, OpenDDS::RTPS::ParticipantProxy_t::guidPrefix, OpenDDS::DCPS::make_id(), participant_volatile_message_secure_reader_, participant_volatile_message_secure_writer_, OpenDDS::Security::SPDPdiscoveredParticipantData::participantProxy, OpenDDS::RTPS::DiscoveredParticipant::pdata_, and spdp_.

 {
   using namespace DDS::Security;
 
   const BuiltinEndpointSet_t local_available = spdp_.available_builtin_endpoints();
   const BuiltinEndpointSet_t remote_available = participant.pdata_.participantProxy.availableBuiltinEndpoints;
 
   if ((local_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER) &&
       (remote_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER)) {
     BuiltinAssociationRecord record(participant_volatile_message_secure_reader_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER),
                                     AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE);
     participant.builtin_pending_records_.push_back(record);
   }
   if ((local_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER) &&
       (remote_available & BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER)) {
     BuiltinAssociationRecord record(participant_volatile_message_secure_writer_,
                                     make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER),
                                     AC_REMOTE_RELIABLE | AC_GENERATE_REMOTE_MATCHED_CRYPTO_HANDLE);
     participant.builtin_pending_records_.push_back(record);
   }
 }

◆ association_complete_i()

void OpenDDS::RTPS::Sedp::association_complete_i	(	const DCPS::GUID_t &	localId,
		const DCPS::GUID_t &	remoteId
	)

Definition at line 2920 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER, OpenDDS::RTPS::ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER, OpenDDS::DCPS::ENTITYID_TL_SVC_REPLY_READER, OpenDDS::RTPS::ENTITYID_TL_SVC_REPLY_READER_SECURE, OpenDDS::DCPS::ENTITYID_TL_SVC_REQ_READER, OpenDDS::RTPS::ENTITYID_TL_SVC_REQ_READER_SECURE, is_expectant_opendds(), LM_DEBUG, local_subscriptions_, resend_user_crypto_tokens(), send_builtin_crypto_tokens(), OpenDDS::RTPS::Spdp::send_participant_crypto_tokens(), spdp_, type_lookup_reply_secure_writer_, type_lookup_reply_writer_, type_lookup_request_secure_writer_, type_lookup_request_writer_, write_durable_dcps_participant_secure(), write_durable_participant_message_data(), write_durable_participant_message_data_secure(), write_durable_publication_data(), write_durable_subscription_data(), and write_subscription_data().

Referenced by OpenDDS::RTPS::Sedp::Writer::transport_assoc_done().

 {
   if (DCPS::DCPS_debug_level) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) DEBUG: Sedp::association_complete_i local %C remote %C\n"),
                DCPS::LogGuid(localId).c_str(),
                DCPS::LogGuid(remoteId).c_str()));
   }
 
   // If the remote endpoint is an opendds endpoint that expects associated datawriter announcements
   if (is_expectant_opendds(remoteId)) {
     LocalSubscriptionIter sub = local_subscriptions_.find(localId);
     // If the local endpoint is a reader
     if (sub != local_subscriptions_.end()) {
       std::pair<DCPS::RepoIdSet::iterator, bool> result =
           sub->second.remote_expectant_opendds_associations_.insert(remoteId);
       // If this is a new association for the local reader
       if (result.second) {
         // Tell other participants
         write_subscription_data(localId, sub->second);
       }
     }
   }
 
 #ifdef OPENDDS_SECURITY
   if (remoteId.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) {
     write_durable_publication_data(remoteId, true);
   } else if (remoteId.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) {
     write_durable_subscription_data(remoteId, true);
   } else if (remoteId.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) {
     write_durable_participant_message_data_secure(remoteId);
   } else if (remoteId.entityId == ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER) {
     write_durable_dcps_participant_secure(remoteId);
   } else if (remoteId.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER) {
     spdp_.send_participant_crypto_tokens(remoteId);
     send_builtin_crypto_tokens(remoteId);
     resend_user_crypto_tokens(remoteId);
   } else if (remoteId.entityId == ENTITYID_TL_SVC_REQ_READER_SECURE) {
     type_lookup_request_secure_writer_->send_deferred_samples(remoteId);
   } else if (remoteId.entityId == ENTITYID_TL_SVC_REPLY_READER_SECURE) {
     type_lookup_reply_secure_writer_->send_deferred_samples(remoteId);
   } else
 #endif
   if (remoteId.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER) {
     write_durable_publication_data(remoteId, false);
   } else if (remoteId.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER) {
     write_durable_subscription_data(remoteId, false);
   } else if (remoteId.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER) {
     write_durable_participant_message_data(remoteId);
   } else if (remoteId.entityId == ENTITYID_TL_SVC_REQ_READER) {
     type_lookup_request_writer_->send_deferred_samples(remoteId);
   } else if (remoteId.entityId == ENTITYID_TL_SVC_REPLY_READER) {
     type_lookup_reply_writer_->send_deferred_samples(remoteId);
   }
 }

◆ cleanup_reader_association()

void OpenDDS::RTPS::Sedp::cleanup_reader_association	(	DCPS::DataReaderCallbacks_wrch	callbacks,
		const GUID_t &	reader,
		const GUID_t &	writer
	)

protected

Definition at line 6759 of file Sedp.cpp.

References OpenDDS::DCPS::EventDispatcher::dispatch(), OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::equal_guid_prefixes(), event_dispatcher_, OpenDDS::DCPS::make_id(), participant_id_, OpenDDS::DCPS::WriterAssociation::participantDiscoveredAt, OpenDDS::RTPS::Spdp::participants_, OpenDDS::DCPS::WriterAssociation::pubQos, spdp_, TheServiceParticipant, OpenDDS::DCPS::WriterAssociation::transportContext, OpenDDS::DCPS::WriterAssociation::writerId, and OpenDDS::DCPS::WriterAssociation::writerQos.

Referenced by match_continue(), and remove_assoc().

 {
   Spdp::DiscoveredParticipantIter part_iter = spdp_.participants_.find(make_id(writer, ENTITYID_PARTICIPANT));
   if (part_iter != spdp_.participants_.end()) {
     for (DiscoveredParticipant::ReaderAssociationRecords::iterator pos = part_iter->second.reader_pending_records_.begin(), limit = part_iter->second.reader_pending_records_.end(); pos != limit; ++pos) {
       if ((*pos)->reader_id() == reader && (*pos)->writer_id() == writer) {
         part_iter->second.reader_pending_records_.erase(pos);
         break;
       }
     }
 
     for (DiscoveredParticipant::ReaderAssociationRecords::iterator pos = part_iter->second.reader_associated_records_.begin(), limit = part_iter->second.reader_associated_records_.end(); pos != limit; ++pos) {
       if ((*pos)->reader_id() == reader && (*pos)->writer_id() == writer) {
         event_dispatcher_->dispatch(DCPS::make_rch<ReaderRemoveAssociations>(*pos));
         part_iter->second.reader_associated_records_.erase(pos);
         break;
       }
     }
   } else if (equal_guid_prefixes(reader, participant_id_) && equal_guid_prefixes(writer, participant_id_)) {
     DCPS::WriterAssociation wa = DCPS::WriterAssociation();
     wa.writerId = writer;
     wa.participantDiscoveredAt = MTZERO;
     wa.pubQos = TheServiceParticipant->initial_PublisherQos();
     wa.writerQos = TheServiceParticipant->initial_DataWriterQos();
     wa.transportContext = 0;
     event_dispatcher_->dispatch(DCPS::make_rch<ReaderRemoveAssociations>(DCPS::make_rch<ReaderAssociationRecord>(callbacks, reader, wa)));
   }
 }

◆ cleanup_secure_reader()

void OpenDDS::RTPS::Sedp::cleanup_secure_reader ( const GUID_t & subscriptionId )

private

Definition at line 6644 of file Sedp.cpp.

References ACE_ERROR, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::Security::HandleRegistry::erase_local_datareader_crypto_handle(), get_crypto_key_factory(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), DDS::HANDLE_NIL, LM_ERROR, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and OpenDDS::DCPS::security_debug.

Referenced by purge_dead_topic(), remove_subscription(), and ~Sedp().

 {
   using namespace DDS::Security;
 
   Security::HandleRegistry_rch handle_registry = get_handle_registry();
   if (!handle_registry) {
     return;
   }
   const DatareaderCryptoHandle drch =
     handle_registry->get_local_datareader_crypto_handle(subscriptionId);
   if (drch == DDS::HANDLE_NIL) {
     return;
   }
 
   SecurityException ex = {"", 0, 0};
   if (!get_crypto_key_factory()->unregister_datareader(drch, ex)) {
     if (DCPS::security_debug.cleanup_error) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) {cleanup_error} Sedp::cleanup_secure_reader() - ")
                  ACE_TEXT("Failure calling unregister_datareader (ch %d).")
                  ACE_TEXT(" Security Exception[%d.%d]: %C\n"),
                  drch, ex.code, ex.minor_code, ex.message.in()));
     }
   }
   handle_registry->erase_local_datareader_crypto_handle(subscriptionId);
 }

◆ cleanup_secure_writer()

void OpenDDS::RTPS::Sedp::cleanup_secure_writer ( const GUID_t & publicationId )

private

Definition at line 6617 of file Sedp.cpp.

References ACE_ERROR, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::Security::HandleRegistry::erase_local_datawriter_crypto_handle(), get_crypto_key_factory(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), DDS::HANDLE_NIL, LM_ERROR, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and OpenDDS::DCPS::security_debug.

Referenced by purge_dead_topic(), remove_publication(), and ~Sedp().

 {
   using namespace DDS::Security;
 
   Security::HandleRegistry_rch handle_registry = get_handle_registry();
   if (!handle_registry) {
     return;
   }
   const DatawriterCryptoHandle dwch =
     handle_registry->get_local_datawriter_crypto_handle(publicationId);
   if (dwch == DDS::HANDLE_NIL) {
     return;
   }
 
   SecurityException ex = {"", 0, 0};
   if (!get_crypto_key_factory()->unregister_datawriter(dwch, ex)) {
     if (DCPS::security_debug.cleanup_error) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) {cleanup_error} Sedp::cleanup_secure_writer() - ")
                  ACE_TEXT("Failure calling unregister_datawriter. (ch %d)")
                  ACE_TEXT(" Security Exception[%d.%d]: %C\n"),
                  dwch, ex.code, ex.minor_code, ex.message.in()));
     }
   }
   handle_registry->erase_local_datawriter_crypto_handle(publicationId);
 }

◆ cleanup_type_lookup_data()

void OpenDDS::RTPS::Sedp::cleanup_type_lookup_data	(	const DCPS::GUID_t &	guid,
		const XTypes::TypeIdentifier &	ti,
		bool	secure
	)

private

Definition at line 4050 of file Sedp.cpp.

References type_lookup_reply_reader_, and type_lookup_reply_secure_reader_.

Referenced by remove_expired_endpoints().

 {
 #ifdef OPENDDS_SECURITY
   if (secure) {
     type_lookup_reply_secure_reader_->cleanup(guid, ti);
   } else {
     type_lookup_reply_reader_->cleanup(guid, ti);
   }
 #else
   ACE_UNUSED_ARG(secure);
   type_lookup_reply_reader_->cleanup(guid, ti);
 #endif
 }

◆ cleanup_volatile_crypto()

void OpenDDS::RTPS::Sedp::cleanup_volatile_crypto ( const DCPS::GUID_t & remote )

Definition at line 1379 of file Sedp.cpp.

References OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, and remove_remote_crypto_handle().

 {
   remove_remote_crypto_handle(remote, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
   remove_remote_crypto_handle(remote, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
 }

◆ cleanup_writer_association()

void OpenDDS::RTPS::Sedp::cleanup_writer_association	(	DCPS::DataWriterCallbacks_wrch	callbacks,
		const GUID_t &	writer,
		const GUID_t &	reader
	)

protected

Definition at line 6728 of file Sedp.cpp.

References OpenDDS::DCPS::EventDispatcher::dispatch(), OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::equal_guid_prefixes(), event_dispatcher_, OpenDDS::DCPS::make_id(), participant_id_, OpenDDS::DCPS::ReaderAssociation::participantDiscoveredAt, OpenDDS::RTPS::Spdp::participants_, OpenDDS::DCPS::ReaderAssociation::readerId, OpenDDS::DCPS::ReaderAssociation::readerQos, spdp_, OpenDDS::DCPS::ReaderAssociation::subQos, TheServiceParticipant, and OpenDDS::DCPS::ReaderAssociation::transportContext.

Referenced by match_continue(), and remove_assoc().

 {
   Spdp::DiscoveredParticipantIter part_iter = spdp_.participants_.find(make_id(reader, ENTITYID_PARTICIPANT));
   if (part_iter != spdp_.participants_.end()) {
     for (DiscoveredParticipant::WriterAssociationRecords::iterator pos = part_iter->second.writer_pending_records_.begin(), limit = part_iter->second.writer_pending_records_.end(); pos != limit; ++pos) {
       if ((*pos)->writer_id() == writer && (*pos)->reader_id() == reader) {
         part_iter->second.writer_pending_records_.erase(pos);
         break;
       }
     }
 
     for (DiscoveredParticipant::WriterAssociationRecords::iterator pos = part_iter->second.writer_associated_records_.begin(), limit = part_iter->second.writer_associated_records_.end(); pos != limit; ++pos) {
       if ((*pos)->writer_id() == writer && (*pos)->reader_id() == reader) {
         event_dispatcher_->dispatch(DCPS::make_rch<WriterRemoveAssociations>(*pos));
         part_iter->second.writer_associated_records_.erase(pos);
         break;
       }
     }
   } else if (equal_guid_prefixes(writer, participant_id_) && equal_guid_prefixes(reader, participant_id_)) {
     DCPS::ReaderAssociation ra = DCPS::ReaderAssociation();
     ra.readerId = reader;
     ra.participantDiscoveredAt = MTZERO;
     ra.subQos = TheServiceParticipant->initial_SubscriberQos();
     ra.readerQos = TheServiceParticipant->initial_DataReaderQos();
     ra.transportContext = 0;
     event_dispatcher_->dispatch(DCPS::make_rch<WriterRemoveAssociations>(DCPS::make_rch<WriterAssociationRecord>(callbacks, writer, ra)));
   }
 }

◆ create_and_send_datareader_crypto_tokens()

void OpenDDS::RTPS::Sedp::create_and_send_datareader_crypto_tokens	(	const DDS::Security::DatareaderCryptoHandle &	drch,
		const DCPS::GUID_t &	local_reader,
		const DDS::Security::DatawriterCryptoHandle &	dwch,
		const DCPS::GUID_t &	remote_writer
	)

protected

Definition at line 1462 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), create_datareader_crypto_tokens(), LM_DEBUG, OpenDDS::DCPS::security_debug, and send_datareader_crypto_tokens().

Referenced by match_continue_security_enabled(), resend_user_crypto_tokens(), and send_builtin_crypto_tokens().

 {
   if (DCPS::security_debug.bookkeeping) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {bookkeeping} ")
                ACE_TEXT("Sedp::create_and_send_datareader_crypto_tokens() - ")
                ACE_TEXT("sending tokens for local reader %C (ch %d) to remote writer %C (ch %d)\n"),
                DCPS::LogGuid(local_reader).c_str(), drch,
                DCPS::LogGuid(remote_writer).c_str(), dwch));
   }
 
   DDS::Security::DatareaderCryptoTokenSeq drcts;
   create_datareader_crypto_tokens(drch, dwch, drcts);
 
   send_datareader_crypto_tokens(local_reader, remote_writer, drcts);
 }

◆ create_and_send_datawriter_crypto_tokens()

void OpenDDS::RTPS::Sedp::create_and_send_datawriter_crypto_tokens	(	const DDS::Security::DatawriterCryptoHandle &	dwch,
		const DCPS::GUID_t &	local_writer,
		const DDS::Security::DatareaderCryptoHandle &	drch,
		const DCPS::GUID_t &	remote_reader
	)

protected

Definition at line 1481 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), create_datawriter_crypto_tokens(), LM_DEBUG, OpenDDS::DCPS::security_debug, and send_datawriter_crypto_tokens().

Referenced by match_continue_security_enabled(), resend_user_crypto_tokens(), and send_builtin_crypto_tokens().

 {
   if (DCPS::security_debug.bookkeeping) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {bookkeeping} ")
                ACE_TEXT("Sedp::create_and_send_datawriter_crypto_tokens() - ")
                ACE_TEXT("sending tokens for local writer %C (ch %d) to remote reader %C (ch %d)\n"),
                DCPS::LogGuid(local_writer).c_str(), dwch,
                DCPS::LogGuid(remote_reader).c_str(), drch));
   }
 
   DDS::Security::DatawriterCryptoTokenSeq dwcts;
   create_datawriter_crypto_tokens(dwch, drch, dwcts);
 
   send_datawriter_crypto_tokens(local_writer, remote_reader, dwcts);
 }

◆ create_datareader_crypto_tokens()

void OpenDDS::RTPS::Sedp::create_datareader_crypto_tokens	(	const DDS::Security::DatareaderCryptoHandle &	drch,
		const DDS::Security::DatawriterCryptoHandle &	dwch,
		DDS::Security::DatareaderCryptoTokenSeq &	drcts
	)

protected

Definition at line 5325 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), OpenDDS::RTPS::Spdp::get_security_config(), LM_WARNING, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and spdp_.

Referenced by create_and_send_datareader_crypto_tokens().

 {
   DDS::Security::SecurityException se = {"", 0, 0};
   DDS::Security::CryptoKeyExchange_var key_exchange = spdp_.get_security_config()->get_crypto_key_exchange();
 
   if (!key_exchange->create_local_datareader_crypto_tokens(drcts, drch, dwch, se)) {
     ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: ")
       ACE_TEXT("Sedp::create_datareader_crypto_tokens() - ")
       ACE_TEXT("Unable to create local datareader crypto tokens with crypto key exchange plugin. ")
       ACE_TEXT("Security Exception[%d.%d]: %C\n"), se.code, se.minor_code, se.message.in()));
   }
 }

◆ create_datawriter_crypto_tokens()

void OpenDDS::RTPS::Sedp::create_datawriter_crypto_tokens	(	const DDS::Security::DatawriterCryptoHandle &	dwch,
		const DDS::Security::DatareaderCryptoHandle &	drch,
		DDS::Security::DatawriterCryptoTokenSeq &	dwcts
	)

protected

Definition at line 5369 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), OpenDDS::RTPS::Spdp::get_security_config(), LM_WARNING, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and spdp_.

Referenced by create_and_send_datawriter_crypto_tokens().

 {
   DDS::Security::SecurityException se = {"", 0, 0};
   DDS::Security::CryptoKeyExchange_var key_exchange = spdp_.get_security_config()->get_crypto_key_exchange();
 
   if (!key_exchange->create_local_datawriter_crypto_tokens(dwcts, dwch, drch, se)) {
     ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: ")
       ACE_TEXT("Sedp::create_datawriter_crypto_tokens() - ")
       ACE_TEXT("Unable to create local datawriter crypto tokens with crypto key exchange plugin. ")
       ACE_TEXT("Security Exception[%d.%d]: %C\n"), se.code, se.minor_code, se.message.in()));
   }
 }

◆ data_acked_i()

void OpenDDS::RTPS::Sedp::data_acked_i	(	const DCPS::GUID_t &	local_id,
		const DCPS::GUID_t &	remote_id
	)

Definition at line 2977 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER, lock_, OpenDDS::DCPS::make_id(), OpenDDS::RTPS::Spdp::participants_, process_association_records_i(), and spdp_.

Referenced by OpenDDS::RTPS::Sedp::Writer::data_acked().

 {
   if (local_id.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER ||
       local_id.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER
 #ifdef OPENDDS_SECURITY
       || local_id.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER
       || local_id.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER
       || local_id.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER
 #endif
       ) {
     const GUID_t remote_part = make_id(remote_id, ENTITYID_PARTICIPANT);
     ACE_GUARD(ACE_Thread_Mutex, g, lock_);
     Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(remote_part);
     if (iter != spdp_.participants_.end()) {
       process_association_records_i(iter->second);
     }
   }
 }

◆ data_received() [1/5]

void OpenDDS::RTPS::Sedp::data_received	(	DCPS::MessageId	message_id,
		const DiscoveredPublication &	wdata
	)

private

Definition at line 2279 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::DCPS::DiscoveredWriterData::ddsPublicationData, OpenDDS::RTPS::Spdp::has_discovered_participant(), OpenDDS::RTPS::DiscoveredPublication::have_ice_agent_info_, OpenDDS::RTPS::DiscoveredPublication::ice_agent_info_, ignoring(), OpenDDS::RTPS::Spdp::initialized(), lock_, OpenDDS::DCPS::make_part_guid(), process_discovered_writer_data(), OpenDDS::DCPS::WriterProxy_t::remoteWriterGuid, OpenDDS::DCPS::SAMPLE_DATA, should_drop_message(), OpenDDS::RTPS::Spdp::shutting_down(), spdp_, OpenDDS::RTPS::DiscoveredPublication::type_info_, OpenDDS::RTPS::DiscoveredPublication::writer_data_, and OpenDDS::DCPS::DiscoveredWriterData::writerProxy.

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

 {
   if (!spdp_.initialized() || spdp_.shutting_down()) { return; }
 
   const DCPS::DiscoveredWriterData& wdata = dpub.writer_data_;
   const GUID_t& guid = wdata.writerProxy.remoteWriterGuid;
   const GUID_t guid_participant = make_part_guid(guid);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid)
       || ignoring(guid_participant)
       || ignoring(wdata.ddsPublicationData.topic_name)) {
     return;
   }
 
 #ifdef OPENDDS_SECURITY
   if (message_id == DCPS::SAMPLE_DATA && should_drop_message(wdata.ddsPublicationData.topic_name)) {
     return;
   }
 #endif
 
   if (!spdp_.has_discovered_participant(guid_participant)) {
     return;
   }
 
   process_discovered_writer_data(message_id, wdata, guid, dpub.type_info_
 #ifdef OPENDDS_SECURITY
                                  , dpub.have_ice_agent_info_, dpub.ice_agent_info_
 #endif
                                  );
 }

◆ data_received() [2/5]

void OpenDDS::RTPS::Sedp::data_received	(	DCPS::MessageId	message_id,
		const ParameterListConverter::DiscoveredPublication_SecurityWrapper &	wrapper
	)

private

Definition at line 2314 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::data, OpenDDS::DCPS::DiscoveredWriterData::ddsPublicationData, OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::have_ice_agent_info, OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::ice_agent_info, ignoring(), OpenDDS::RTPS::Spdp::initialized(), lock_, OpenDDS::DCPS::make_part_guid(), process_discovered_writer_data(), OpenDDS::DCPS::WriterProxy_t::remoteWriterGuid, OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::security_info, OpenDDS::RTPS::Spdp::shutting_down(), spdp_, OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::type_info, and OpenDDS::DCPS::DiscoveredWriterData::writerProxy.

 {
   if (!spdp_.initialized() || spdp_.shutting_down()) { return; }
 
   const GUID_t& guid = wrapper.data.writerProxy.remoteWriterGuid;
   const GUID_t guid_participant = make_part_guid(guid);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid)
       || ignoring(guid_participant)
       || ignoring(wrapper.data.ddsPublicationData.topic_name)) {
     return;
   }
 
   process_discovered_writer_data(message_id, wrapper.data, guid, wrapper.type_info,
                                  wrapper.have_ice_agent_info, wrapper.ice_agent_info,
                                  &wrapper.security_info);
 }

◆ data_received() [3/5]

void OpenDDS::RTPS::Sedp::data_received	(	DCPS::MessageId	message_id,
		const DiscoveredSubscription &	rdata
	)

private

Definition at line 2615 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::DCPS::DiscoveredReaderData::ddsSubscriptionData, OpenDDS::RTPS::Spdp::has_discovered_participant(), OpenDDS::RTPS::DiscoveredSubscription::have_ice_agent_info_, OpenDDS::RTPS::DiscoveredSubscription::ice_agent_info_, ignoring(), OpenDDS::RTPS::Spdp::initialized(), lock_, OpenDDS::DCPS::make_part_guid(), process_discovered_reader_data(), OpenDDS::RTPS::DiscoveredSubscription::reader_data_, OpenDDS::DCPS::DiscoveredReaderData::readerProxy, OpenDDS::DCPS::ReaderProxy_t::remoteReaderGuid, OpenDDS::DCPS::SAMPLE_DATA, should_drop_message(), OpenDDS::RTPS::Spdp::shutting_down(), spdp_, and OpenDDS::RTPS::DiscoveredSubscription::type_info_.

 {
   if (!spdp_.initialized() || spdp_.shutting_down()) { return; }
 
   const DCPS::DiscoveredReaderData& rdata = dsub.reader_data_;
   const GUID_t& guid = rdata.readerProxy.remoteReaderGuid;
   const GUID_t part_guid = make_part_guid(guid);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid) || ignoring(part_guid)
       || ignoring(rdata.ddsSubscriptionData.topic_name)) {
     return;
   }
 
 #ifdef OPENDDS_SECURITY
   if (message_id == DCPS::SAMPLE_DATA && should_drop_message(rdata.ddsSubscriptionData.topic_name)) {
     return;
   }
 #endif
 
   if (!spdp_.has_discovered_participant(part_guid)) {
     return;
   }
 
   process_discovered_reader_data(message_id, rdata, guid, dsub.type_info_
 #ifdef OPENDDS_SECURITY
                                  , dsub.have_ice_agent_info_, dsub.ice_agent_info_
 #endif
                                  );
 }

◆ data_received() [4/5]

void OpenDDS::RTPS::Sedp::data_received	(	DCPS::MessageId	message_id,
		const ParameterListConverter::DiscoveredSubscription_SecurityWrapper &	wrapper
	)

private

Definition at line 2649 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::data, OpenDDS::DCPS::DiscoveredReaderData::ddsSubscriptionData, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::have_ice_agent_info, OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::ice_agent_info, ignoring(), OpenDDS::RTPS::Spdp::initialized(), lock_, process_discovered_reader_data(), OpenDDS::DCPS::DiscoveredReaderData::readerProxy, OpenDDS::DCPS::ReaderProxy_t::remoteReaderGuid, OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::security_info, OpenDDS::RTPS::Spdp::shutting_down(), spdp_, and OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::type_info.

 {
   if (!spdp_.initialized() || spdp_.shutting_down()) { return; }
 
   const GUID_t& guid = wrapper.data.readerProxy.remoteReaderGuid;
   GUID_t guid_participant = guid;
   guid_participant.entityId = ENTITYID_PARTICIPANT;
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid)
       || ignoring(guid_participant)
       || ignoring(wrapper.data.ddsSubscriptionData.topic_name)) {
     return;
   }
 
   process_discovered_reader_data(message_id, wrapper.data, guid, wrapper.type_info, wrapper.have_ice_agent_info, wrapper.ice_agent_info, &wrapper.security_info);
 }

◆ data_received() [5/5]

void OpenDDS::RTPS::Sedp::data_received	(	DCPS::MessageId	message_id,
		const ParticipantMessageData &	data
	)

private

Definition at line 2705 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::RTPS::Spdp::has_discovered_participant(), ignoring(), OpenDDS::RTPS::Spdp::initialized(), lock_, OpenDDS::DCPS::make_part_guid(), notify_liveliness(), OpenDDS::RTPS::ParticipantMessageData::participantGuid, OpenDDS::RTPS::Spdp::shutting_down(), and spdp_.

 {
   if (!spdp_.initialized() || spdp_.shutting_down()) {
     return;
   }
 
   const GUID_t& guid = data.participantGuid;
   const GUID_t guid_participant = make_part_guid(guid);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid) || ignoring(guid_participant)) {
     return;
   }
 
   if (!spdp_.has_discovered_participant(guid_participant)) {
     return;
   }
   notify_liveliness(data);
 }

◆ disassociate()

void OpenDDS::RTPS::Sedp::disassociate ( DiscoveredParticipant & participant )

Definition at line 1544 of file Sedp.cpp.

Referenced by OpenDDS::RTPS::Spdp::purge_discovered_participant().

 {
   const GUID_t part = make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_PARTICIPANT);
 
   associated_participants_.erase(part);
 
   OPENDDS_VECTOR(DiscoveredPublication) pubs_to_remove_from_bit;
   OPENDDS_VECTOR(DiscoveredSubscription) subs_to_remove_from_bit;
 
   remove_entities_belonging_to(discovered_publications_, part, false, pubs_to_remove_from_bit);
   remove_entities_belonging_to(discovered_subscriptions_, part, true, subs_to_remove_from_bit);
 
   for (OPENDDS_VECTOR(DiscoveredPublication)::iterator it = pubs_to_remove_from_bit.begin(); it != pubs_to_remove_from_bit.end(); ++it) {
     remove_from_bit_i(*it);
   }
 
   for (OPENDDS_VECTOR(DiscoveredSubscription)::iterator it = subs_to_remove_from_bit.begin(); it != subs_to_remove_from_bit.end(); ++it) {
     remove_from_bit_i(*it);
   }
 
   participant.builtin_pending_records_.clear();
 
   for (DiscoveredParticipant::BuiltinAssociationRecords::const_iterator pos = participant.builtin_associated_records_.begin(), limit = participant.builtin_associated_records_.end(); pos != limit; ++pos) {
     const BuiltinAssociationRecord& record = *pos;
     record.transport_client_->disassociate(record.remote_id());
   }
 
   participant.builtin_associated_records_.clear();
 
   //FUTURE: if/when topic propagation is supported, add it here
 
 #ifdef OPENDDS_SECURITY
   // Clean up crypto handles after diassociation because the transport might be using them.
   if (spdp_.is_security_enabled()) {
     static const EntityId_t secure_entities[] = {
       ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER,
       ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER,
       ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER,
       ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER,
       ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER,
       ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER,
       ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER,
       ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER,
       ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER,
       ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER,
       ENTITYID_TL_SVC_REQ_WRITER_SECURE,
       ENTITYID_TL_SVC_REQ_READER_SECURE,
       ENTITYID_TL_SVC_REPLY_WRITER_SECURE,
       ENTITYID_TL_SVC_REPLY_READER_SECURE
     };
     for (size_t i = 0; i < DCPS::array_count(secure_entities); ++i) {
       remove_remote_crypto_handle(part, secure_entities[i]);
     }
 
     const DDS::Security::CryptoKeyFactory_var key_factory = spdp_.get_security_config()->get_crypto_key_factory();
     DDS::Security::SecurityException se;
 
     typedef Security::HandleRegistry::DatareaderCryptoHandleList DatareaderCryptoHandleList;
     typedef Security::HandleRegistry::DatawriterCryptoHandleList DatawriterCryptoHandleList;
 
     const GUID_t key = make_unknown_guid(part);
     const DatareaderCryptoHandleList drlist = get_handle_registry()->get_all_remote_datareaders(key);
     for (DatareaderCryptoHandleList::const_iterator pos = drlist.begin(), limit = drlist.end();
          pos != limit; ++pos) {
       if (!key_factory->unregister_datareader(pos->second, se)) {
         if (DCPS::security_debug.cleanup_error) {
           ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) {cleanup_error} Sedp::disassociate() - ")
                      ACE_TEXT("Failure calling unregister_datareader() (ch %d). Security Exception[%d.%d]: %C\n"),
                      pos->second, se.code, se.minor_code, se.message.in()));
         }
       }
       get_handle_registry()->erase_remote_datareader_crypto_handle(pos->first);
     }
     const DatawriterCryptoHandleList dwlist = get_handle_registry()->get_all_remote_datawriters(key);
     for (DatawriterCryptoHandleList::const_iterator pos = dwlist.begin(), limit = dwlist.end();
          pos != limit; ++pos) {
       if (!key_factory->unregister_datawriter(pos->second, se)) {
         if (DCPS::security_debug.cleanup_error) {
           ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) {cleanup_error} Sedp::disassociate() - ")
                      ACE_TEXT("Failure calling unregister_datawriter() (ch %d). Security Exception[%d.%d]: %C\n"),
                      pos->second, se.code, se.minor_code, se.message.in()));
         }
       }
       get_handle_registry()->erase_remote_datawriter_crypto_handle(pos->first);
     }
   }
 #endif
 }

◆ disassociate_volatile()

void OpenDDS::RTPS::Sedp::disassociate_volatile ( DiscoveredParticipant & participant )

Definition at line 1345 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredParticipant::builtin_associated_records_, OpenDDS::RTPS::DiscoveredParticipant::builtin_pending_records_, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER, OpenDDS::RTPS::ParticipantProxy_t::guidPrefix, OpenDDS::RTPS::BuiltinAssociationRecord::local_id(), OpenDDS::DCPS::make_id(), participant_id_, OpenDDS::Security::SPDPdiscoveredParticipantData::participantProxy, OpenDDS::RTPS::DiscoveredParticipant::pdata_, OpenDDS::RTPS::BuiltinAssociationRecord::remote_id(), and OpenDDS::RTPS::BuiltinAssociationRecord::transport_client_.

 {
   const GUID_t local_writer = make_id(participant_id_, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
   const GUID_t local_reader = make_id(participant_id_, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
   const GUID_t remote_writer = make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
   const GUID_t remote_reader = make_id(participant.pdata_.participantProxy.guidPrefix, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
 
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = participant.builtin_pending_records_.begin(),
          limit = participant.builtin_pending_records_.end(); pos != limit;) {
     const BuiltinAssociationRecord& record = *pos;
     if (record.local_id() == local_writer && record.remote_id() == remote_reader) {
       participant.builtin_pending_records_.erase(pos++);
     } else if (record.local_id() == local_reader && record.remote_id() == remote_writer) {
       participant.builtin_pending_records_.erase(pos++);
     } else {
       ++pos;
     }
   }
 
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = participant.builtin_associated_records_.begin(),
          limit = participant.builtin_associated_records_.end(); pos != limit;) {
     const BuiltinAssociationRecord& record = *pos;
     if (record.local_id() == local_writer && record.remote_id() == remote_reader) {
       record.transport_client_->disassociate(record.remote_id());
       participant.builtin_associated_records_.erase(pos++);
     } else if (record.local_id() == local_reader && record.remote_id() == remote_writer) {
       record.transport_client_->disassociate(record.remote_id());
       participant.builtin_associated_records_.erase(pos++);
     } else {
       ++pos;
     }
   }
 }

◆ find_topic()

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

Definition at line 6085 of file Sedp.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::FOUND, OpenDDS::DCPS::INTERNAL_ERROR, OpenDDS::DCPS::TopicDetails::local_data_type_name(), OpenDDS::DCPS::TopicDetails::local_qos(), OpenDDS::DCPS::TransportClient::lock_, OpenDDS::DCPS::NOT_FOUND, OpenDDS::DCPS::TopicDetails::topic_id(), Update::TopicQos, and topics_.

Referenced by ignoring().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, DCPS::INTERNAL_ERROR);
   DCPS::TopicDetailsMap::const_iterator iter = topics_.find(topicName);
   if (iter == topics_.end()) {
     return DCPS::NOT_FOUND;
   }
 
   const DCPS::TopicDetails& td = iter->second;
 
   dataTypeName = td.local_data_type_name().c_str();
   qos = new DDS::TopicQos(td.local_qos());
   topicId = td.topic_id();
   return DCPS::FOUND;
 }

◆ generate_remote_matched_crypto_handle()

void OpenDDS::RTPS::Sedp::generate_remote_matched_crypto_handle ( const BuiltinAssociationRecord & record )

Definition at line 1012 of file Sedp.cpp.

References generate_remote_matched_reader_crypto_handle(), generate_remote_matched_writer_crypto_handle(), OpenDDS::RTPS::BuiltinAssociationRecord::local_id(), and OpenDDS::RTPS::BuiltinAssociationRecord::remote_id().

Referenced by generate_remote_matched_crypto_handles().

 {
   if (DCPS::GuidConverter(record.remote_id()).isWriter()) {
     generate_remote_matched_writer_crypto_handle(record.remote_id(), record.local_id());
   } else {
     generate_remote_matched_reader_crypto_handle(record.remote_id(), record.local_id(), false);
   }
 }

◆ generate_remote_matched_crypto_handles()

void OpenDDS::RTPS::Sedp::generate_remote_matched_crypto_handles ( DiscoveredParticipant & participant )

Definition at line 1334 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredParticipant::builtin_pending_records_, OpenDDS::RTPS::BuiltinAssociationRecord::generate_remote_matched_crypto_handle(), and generate_remote_matched_crypto_handle().

 {
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = participant.builtin_pending_records_.begin(),
          limit = participant.builtin_pending_records_.end(); pos != limit; ++pos) {
     const BuiltinAssociationRecord& record = *pos;
     if (record.generate_remote_matched_crypto_handle()) {
       generate_remote_matched_crypto_handle(record);
     }
   }
 }

◆ generate_remote_matched_reader_crypto_handle()

DDS::Security::DatareaderCryptoHandle OpenDDS::RTPS::Sedp::generate_remote_matched_reader_crypto_handle	(	const DCPS::GUID_t &	reader,
		const DCPS::GUID_t &	writer,
		bool	relay_only
	)

protected

Definition at line 5291 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_factory(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datawriter_security_attributes(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::RTPS::Spdp::get_security_config(), DDS::HANDLE_NIL, OpenDDS::Security::HandleRegistry::insert_remote_datareader_crypto_handle(), LM_WARNING, OpenDDS::RTPS::Spdp::lookup_participant_crypto_info(), OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and spdp_.

Referenced by generate_remote_matched_crypto_handle(), and match_continue_security_enabled().

 {
   DDS::Security::DatareaderCryptoHandle result = get_handle_registry()->get_remote_datareader_crypto_handle(reader);
   if (result != DDS::HANDLE_NIL) {
     return result;
   }
 
   const GUID_t reader_part = make_id(reader, ENTITYID_PARTICIPANT);
   Spdp::ParticipantCryptoInfoPair info = spdp_.lookup_participant_crypto_info(reader_part);
 
   if (info.first != DDS::HANDLE_NIL && info.second) {
     const DDS::Security::DatawriterCryptoHandle dwch =
       get_handle_registry()->get_local_datawriter_crypto_handle(writer);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_local_datawriter_security_attributes(writer);
     DDS::Security::CryptoKeyFactory_var key_factory = spdp_.get_security_config()->get_crypto_key_factory();
     DDS::Security::SecurityException se = {"", 0, 0};
     result = key_factory->register_matched_remote_datareader(dwch, info.first, info.second, relay_only, se);
     get_handle_registry()->insert_remote_datareader_crypto_handle(reader, result, attribs);
     if (result == DDS::HANDLE_NIL) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::generate_remote_matched_reader_crypto_handle() - ")
         ACE_TEXT("Failure calling register_matched_remote_datareader(). Security Exception[%d.%d]: %C\n"),
           se.code, se.minor_code, se.message.in()));
     }
   } else {
     ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::generate_remote_matched_reader_crypto_handle() - ")
       ACE_TEXT("Unable to lookup remote participant crypto info.\n")));
   }
   return result;
 }

◆ generate_remote_matched_writer_crypto_handle()

DDS::Security::DatawriterCryptoHandle OpenDDS::RTPS::Sedp::generate_remote_matched_writer_crypto_handle	(	const DCPS::GUID_t &	writer,
		const DCPS::GUID_t &	reader
	)

protected

Definition at line 5258 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_factory(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datareader_security_attributes(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), OpenDDS::RTPS::Spdp::get_security_config(), DDS::HANDLE_NIL, OpenDDS::Security::HandleRegistry::insert_remote_datawriter_crypto_handle(), LM_WARNING, OpenDDS::RTPS::Spdp::lookup_participant_crypto_info(), OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, and spdp_.

Referenced by generate_remote_matched_crypto_handle(), and match_continue_security_enabled().

 {
   DDS::Security::DatawriterCryptoHandle result = get_handle_registry()->get_remote_datawriter_crypto_handle(writer);
   if (result != DDS::HANDLE_NIL) {
     return result;
   }
 
   const GUID_t writer_part = make_id(writer, ENTITYID_PARTICIPANT);
   Spdp::ParticipantCryptoInfoPair info = spdp_.lookup_participant_crypto_info(writer_part);
 
   if (info.first != DDS::HANDLE_NIL && info.second) {
     const DDS::Security::DatareaderCryptoHandle drch =
       get_handle_registry()->get_local_datareader_crypto_handle(reader);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_local_datareader_security_attributes(reader);
     DDS::Security::CryptoKeyFactory_var key_factory = spdp_.get_security_config()->get_crypto_key_factory();
     DDS::Security::SecurityException se = {"", 0, 0};
     result = key_factory->register_matched_remote_datawriter(drch, info.first, info.second, se);
     get_handle_registry()->insert_remote_datawriter_crypto_handle(writer, result, attribs);
     if (result == DDS::HANDLE_NIL) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::generate_remote_matched_writer_crypto_handle() - ")
         ACE_TEXT("Failure calling register_matched_remote_datawriter(). Security Exception[%d.%d]: %C\n"),
           se.code, se.minor_code, se.message.in()));
     }
   } else {
     ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::generate_remote_matched_writer_crypto_handle() - ")
       ACE_TEXT("Unable to lookup remote participant crypto info.\n")));
   }
   return result;
 }

◆ get_access_control()

DDS::Security::AccessControl_var OpenDDS::RTPS::Sedp::get_access_control ( ) const

inlineprotected

Definition at line 1196 of file Sedp.h.

References access_control_.

Referenced by add_publication(), add_subscription(), process_discovered_reader_data(), process_discovered_writer_data(), should_drop_message(), and signal_liveliness().

   {
     return access_control_;
   }

◆ get_crypto_key_exchange()

DDS::Security::CryptoKeyExchange_var OpenDDS::RTPS::Sedp::get_crypto_key_exchange ( ) const

inlineprotected

Definition at line 1216 of file Sedp.h.

References crypto_key_exchange_.

Referenced by match_continue_security_enabled().

   {
     return crypto_key_exchange_;
   }

◆ get_crypto_key_factory()

DDS::Security::CryptoKeyFactory_var OpenDDS::RTPS::Sedp::get_crypto_key_factory ( ) const

inlineprotected

Definition at line 1206 of file Sedp.h.

References crypto_key_factory_.

Referenced by add_publication(), add_subscription(), cleanup_secure_reader(), and cleanup_secure_writer().

   {
     return crypto_key_factory_;
   }

◆ get_domain_id()

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

protected

Definition at line 5538 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::get_domain_id(), and spdp_.

Referenced by add_publication(), and add_subscription().

                                         {
   return spdp_.get_domain_id();
 }

◆ get_handle_registry()

Security::HandleRegistry_rch OpenDDS::RTPS::Sedp::get_handle_registry ( ) const

inline

Definition at line 257 of file Sedp.h.

References handle_registry_.

Referenced by add_publication(), add_subscription(), cleanup_secure_reader(), cleanup_secure_writer(), disassociate(), generate_remote_matched_reader_crypto_handle(), generate_remote_matched_writer_crypto_handle(), handle_datareader_crypto_tokens(), handle_datawriter_crypto_tokens(), init_security(), local_has_remote_endpoint_token_i(), local_has_remote_participant_token_i(), match_continue_security_enabled(), remote_has_local_endpoint_token_i(), remote_has_local_participant_token_i(), remove_remote_crypto_handle(), resend_user_crypto_tokens(), and send_builtin_crypto_tokens().

   {
     return handle_registry_;
   }

◆ get_ice_endpoint()

DCPS::WeakRcHandle< ICE::Endpoint > OpenDDS::RTPS::Sedp::get_ice_endpoint ( )

Definition at line 3117 of file Sedp.cpp.

References OpenDDS::DCPS::TransportInst::get_ice_endpoint(), and transport_inst_.

                                                      {
   return transport_inst_->get_ice_endpoint();
 }

◆ get_key() [1/2]

static DDS::BuiltinTopicKey_t OpenDDS::RTPS::Sedp::get_key ( const DiscoveredPublication & pub )

inlinestaticprotected

Definition at line 1009 of file Sedp.h.

References OpenDDS::DCPS::DiscoveredWriterData::ddsPublicationData, and OpenDDS::RTPS::DiscoveredPublication::writer_data_.

   {
     return pub.writer_data_.ddsPublicationData.key;
   }

◆ get_key() [2/2]

static DDS::BuiltinTopicKey_t OpenDDS::RTPS::Sedp::get_key ( const DiscoveredSubscription & sub )

inlinestaticprotected

Definition at line 1013 of file Sedp.h.

References OpenDDS::DCPS::DiscoveredReaderData::ddsSubscriptionData, and OpenDDS::RTPS::DiscoveredSubscription::reader_data_.

   {
     return sub.reader_data_.ddsSubscriptionData.key;
   }

◆ get_permissions_handle()

DDS::Security::PermissionsHandle OpenDDS::RTPS::Sedp::get_permissions_handle ( ) const

inlineprotected

Definition at line 1186 of file Sedp.h.

References permissions_handle_.

Referenced by add_publication(), add_subscription(), should_drop_message(), and signal_liveliness().

   {
     return permissions_handle_;
   }

◆ get_remote_type_objects()

void OpenDDS::RTPS::Sedp::get_remote_type_objects	(	const XTypes::TypeIdentifierWithDependencies &	tid_with_deps,
		MatchingData &	md,
		bool	get_minimal,
		const GUID_t &	remote_id,
		bool	is_discovery_protected
	)

protected

Definition at line 7529 of file Sedp.cpp.

Referenced by request_type_objects().

 {
   // Store an entry for the first request in the sequence.
   TypeIdOrigSeqNumber orig_req_data;
   orig_req_data.participant = make_part_guid(remote_id);
   orig_req_data.type_id = tid_with_deps.typeid_with_size.type_id;
   const SequenceNumber& orig_seqnum = get_minimal ? md.rpc_seqnum_minimal : md.rpc_seqnum_complete;
   orig_req_data.seq_number = orig_seqnum;
   orig_req_data.secure = false;
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled() && is_discovery_protected) {
     orig_req_data.secure = true;
   }
 #endif
   orig_req_data.time_started = md.time_added_to_map;
   orig_seq_numbers_.insert(std::make_pair(orig_seqnum, orig_req_data));
 
   XTypes::TypeIdentifierSeq type_ids;
   if (tid_with_deps.dependent_typeid_count == -1 ||
       tid_with_deps.dependent_typeids.length() < (CORBA::ULong)tid_with_deps.dependent_typeid_count) {
     type_ids.append(tid_with_deps.typeid_with_size.type_id);
 
     // Get dependencies of the topic type. TypeObjects of both topic type and
     // its dependencies are obtained in subsequent type lookup requests.
     send_type_lookup_request(type_ids, remote_id, is_discovery_protected, false, orig_req_data.seq_number);
   } else {
     type_ids.length(tid_with_deps.dependent_typeid_count + 1);
     type_ids[0] = tid_with_deps.typeid_with_size.type_id;
     for (unsigned i = 1; i <= (unsigned)tid_with_deps.dependent_typeid_count; ++i) {
       type_ids[i] = tid_with_deps.dependent_typeids[i - 1].type_id;
     }
 
     // Get TypeObjects of topic type and all of its dependencies.
     send_type_lookup_request(type_ids, remote_id, is_discovery_protected, true, orig_req_data.seq_number);
   }
   type_lookup_reply_deadline_processor_->schedule(max_type_lookup_service_reply_period_);
 }

◆ handle_datareader_crypto_tokens()

bool OpenDDS::RTPS::Sedp::handle_datareader_crypto_tokens ( const DDS::Security::ParticipantVolatileMessageSecure & msg )

protected

Definition at line 5476 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), DDS::Security::SecurityException::code, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::RTPS::Spdp::get_security_config(), DDS::HANDLE_NIL, LM_DEBUG, LM_ERROR, LM_WARNING, OpenDDS::DCPS::TransportClient::lock_, OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::SecurityException::minor_code, OpenDDS::RTPS::Spdp::participants_, pending_remote_reader_crypto_tokens_, process_association_records_i(), OpenDDS::DCPS::security_debug, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, and spdp_.

Referenced by received_volatile_message_secure().

                                                                                             {
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Sedp::handle_datareader_crypto_tokens() %C\n"),
                DCPS::LogGuid(msg.source_endpoint_guid).c_str()));
   }
 
   DDS::Security::SecurityException se = {"", 0, 0};
   Security::CryptoKeyExchange_var key_exchange = spdp_.get_security_config()->get_crypto_key_exchange();
 
   ACE_Guard<ACE_Thread_Mutex> g(lock_, false);
 
   const DDS::Security::DatareaderCryptoHandle drch =
     get_handle_registry()->get_remote_datareader_crypto_handle(msg.source_endpoint_guid);
   const DDS::Security::DatawriterCryptoHandle dwch =
     get_handle_registry()->get_local_datawriter_crypto_handle(msg.destination_endpoint_guid);
 
   DDS::Security::DatareaderCryptoTokenSeq drcts;
   drcts = reinterpret_cast<const DDS::Security::DatareaderCryptoTokenSeq&>(msg.message_data);
 
   if (drch == DDS::HANDLE_NIL) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG,
         ACE_TEXT("(%P|%t) Sedp::handle_datareader_crypto_tokens() - ")
         ACE_TEXT("received tokens for unknown remote reader %C Caching.\n"),
         DCPS::LogGuid(msg.source_endpoint_guid).c_str()));
     }
 
     pending_remote_reader_crypto_tokens_[msg.source_endpoint_guid] = drcts;
     return true;
   }
 
   if (dwch == DDS::HANDLE_NIL) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_WARNING,
         ACE_TEXT("(%P|%t) Sedp::handle_datareader_crypto_tokens() - ")
         ACE_TEXT("received tokens for unknown local writer. Ignoring.\n")));
     }
     return false;
   }
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Sedp::handle_datareader_crypto_tokens() from %C dwch %d drch %d count %d\n"),
                DCPS::LogGuid(msg.source_endpoint_guid).c_str(), dwch, drch, drcts.length()));
   }
 
   if (!key_exchange->set_remote_datareader_crypto_tokens(dwch, drch, drcts, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::handle_datareader_crypto_tokens() - ")
       ACE_TEXT("Unable to set remote datareader 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;
   }
 
   Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(make_id(msg.source_endpoint_guid, ENTITYID_PARTICIPANT));
   if (iter != spdp_.participants_.end()) {
     process_association_records_i(iter->second);
   }
 
   return true;
 }

◆ handle_datawriter_crypto_tokens()

bool OpenDDS::RTPS::Sedp::handle_datawriter_crypto_tokens ( const DDS::Security::ParticipantVolatileMessageSecure & msg )

protected

Definition at line 5413 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::LogGuid::c_str(), DDS::Security::SecurityException::code, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), OpenDDS::RTPS::Spdp::get_security_config(), DDS::HANDLE_NIL, LM_DEBUG, LM_ERROR, LM_WARNING, OpenDDS::DCPS::TransportClient::lock_, OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::SecurityException::minor_code, OpenDDS::RTPS::Spdp::participants_, pending_remote_writer_crypto_tokens_, process_association_records_i(), OpenDDS::DCPS::security_debug, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, and spdp_.

Referenced by received_volatile_message_secure().

                                                                                             {
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Sedp::handle_datawriter_crypto_tokens() %C\n"),
                DCPS::LogGuid(msg.source_endpoint_guid).c_str()));
   }
 
   DDS::Security::SecurityException se = {"", 0, 0};
   Security::CryptoKeyExchange_var key_exchange = spdp_.get_security_config()->get_crypto_key_exchange();
 
   ACE_Guard<ACE_Thread_Mutex> g(lock_, false);
 
   const DDS::Security::DatawriterCryptoHandle dwch =
     get_handle_registry()->get_remote_datawriter_crypto_handle(msg.source_endpoint_guid);
   const DDS::Security::DatareaderCryptoHandle drch =
     get_handle_registry()->get_local_datareader_crypto_handle(msg.destination_endpoint_guid);
 
   DDS::Security::DatawriterCryptoTokenSeq dwcts;
   dwcts = reinterpret_cast<const DDS::Security::DatawriterCryptoTokenSeq&>(msg.message_data);
 
   if (dwch == DDS::HANDLE_NIL) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG,
         ACE_TEXT("(%P|%t) Sedp::handle_datawriter_crypto_tokens() - ")
         ACE_TEXT("received tokens for unknown remote writer %C Caching.\n"),
         DCPS::LogGuid(msg.source_endpoint_guid).c_str()));
     }
 
     pending_remote_writer_crypto_tokens_[msg.source_endpoint_guid] = dwcts;
     return true;
   }
 
   if (drch == DDS::HANDLE_NIL) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_WARNING,
         ACE_TEXT("(%P|%t) Sedp::handle_datawriter_crypto_tokens() - ")
         ACE_TEXT("received tokens for unknown local reader. Ignoring.\n")));
     }
     return false;
   }
 
   if (DCPS::security_debug.auth_debug) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Sedp::handle_datawriter_crypto_tokens() from %C drch %d dwch %d count %d\n"),
                DCPS::LogGuid(msg.source_endpoint_guid).c_str(), drch, dwch, dwcts.length()));
   }
 
   if (!key_exchange->set_remote_datawriter_crypto_tokens(drch, dwch, dwcts, se)) {
     ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: Sedp::handle_datawriter_crypto_tokens() - ")
       ACE_TEXT("Unable to set remote datawriter 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;
   }
 
   Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(make_id(msg.source_endpoint_guid, ENTITYID_PARTICIPANT));
   if (iter != spdp_.participants_.end()) {
     process_association_records_i(iter->second);
   }
 
   return true;
 }

◆ has_dcps_key()

bool OpenDDS::RTPS::Sedp::has_dcps_key ( const GUID_t & topicId ) const

inlineprotected

Definition at line 1163 of file Sedp.h.

References OPENDDS_MAP_CMP(), topic_names_, and topics_.

Referenced by assign_publication_key(), and assign_subscription_key().

   {
     typedef OPENDDS_MAP_CMP(GUID_t, String, GUID_tKeyLessThan) TNMap;
     TNMap::const_iterator tn = topic_names_.find(topicId);
     if (tn == topic_names_.end()) return false;
 
     DCPS::TopicDetailsMap::const_iterator td = topics_.find(tn->second);
     if (td == topics_.end()) return false;
 
     return td->second.has_dcps_key();
   }

◆ ignore()

void OpenDDS::RTPS::Sedp::ignore ( const GUID_t & to_ignore )

Definition at line 5988 of file Sedp.cpp.

References OpenDDS::DCPS::TopicDetails::discovered_publications(), discovered_publications_, OpenDDS::DCPS::TopicDetails::discovered_subscriptions(), discovered_subscriptions_, ignored_guids_, OpenDDS::DCPS::TopicDetails::is_dead(), match_endpoints(), OpenDDS::DCPS::TransportClient::OPENDDS_MAP_CMP(), purge_dead_topic(), OpenDDS::DCPS::TopicDetails::remove_discovered_publication(), OpenDDS::DCPS::TopicDetails::remove_discovered_subscription(), remove_from_bit(), OpenDDS::RTPS::Sedp::Endpoint::shutting_down(), topic_names_, and topics_.

Referenced by OpenDDS::RTPS::Spdp::ignore_domain_participant(), and job_queue().

 {
   // Locked prior to call from Spdp.
   ignored_guids_.insert(to_ignore);
   {
     const DiscoveredPublicationIter iter =
       discovered_publications_.find(to_ignore);
     if (iter != discovered_publications_.end()) {
       // clean up tracking info
       const String topic_name = iter->second.get_topic_name();
       DCPS::TopicDetails& td = topics_[topic_name];
       td.remove_discovered_publication(to_ignore);
       remove_from_bit(iter->second);
       discovered_publications_.erase(iter);
       // break associations
       match_endpoints(to_ignore, td, true /*remove*/);
       if (td.is_dead()) {
         purge_dead_topic(topic_name);
       }
       return;
     }
   }
   {
     const DiscoveredSubscriptionIter iter =
       discovered_subscriptions_.find(to_ignore);
     if (iter != discovered_subscriptions_.end()) {
       // clean up tracking info
       const String topic_name = iter->second.get_topic_name();
       DCPS::TopicDetails& td = topics_[topic_name];
       td.remove_discovered_publication(to_ignore);
       remove_from_bit(iter->second);
       discovered_subscriptions_.erase(iter);
       // break associations
       match_endpoints(to_ignore, td, true /*remove*/);
       if (td.is_dead()) {
         purge_dead_topic(topic_name);
       }
       return;
     }
   }
   {
     const OPENDDS_MAP_CMP(GUID_t, String, GUID_tKeyLessThan)::iterator
       iter = topic_names_.find(to_ignore);
     if (iter != topic_names_.end()) {
       ignored_topics_.insert(iter->second);
       // Remove all publications and subscriptions on this topic
       DCPS::TopicDetails& td = topics_[iter->second];
       {
         const RepoIdSet ids = td.discovered_publications();
         for (RepoIdSet::const_iterator ep = ids.begin(); ep!= ids.end(); ++ep) {
           match_endpoints(*ep, td, true /*remove*/);
           td.remove_discovered_publication(*ep);
           // TODO: Do we need to remove from discovered_subscriptions?
           if (shutting_down()) { return; }
         }
       }
       {
         const RepoIdSet ids = td.discovered_subscriptions();
         for (RepoIdSet::const_iterator ep = ids.begin(); ep!= ids.end(); ++ep) {
           match_endpoints(*ep, td, true /*remove*/);
           td.remove_discovered_subscription(*ep);
           // TODO: Do we need to remove from discovered_publications?
           if (shutting_down()) { return; }
         }
       }
       if (td.is_dead()) {
         purge_dead_topic(iter->second);
       }
     }
   }
 }

◆ ignoring() [1/2]

bool OpenDDS::RTPS::Sedp::ignoring ( const GUID_t & guid ) const

inline

Definition at line 205 of file Sedp.h.

References ignored_guids_.

Referenced by data_received(), received_participant_message_data_secure(), should_drop_stateless_message(), and should_drop_volatile_message().

   {
     return ignored_guids_.count(guid);
   }

◆ ignoring() [2/2]

bool OpenDDS::RTPS::Sedp::ignoring ( const char * topic_name ) const

inline

Definition at line 209 of file Sedp.h.

References add_publication(), add_subscription(), assert_topic(), find_topic(), remove_publication(), remove_subscription(), remove_topic(), update_publication_locators(), and update_subscription_locators().

   {
     return ignored_topics_.count(topic_name);
   }

◆ init()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::init	(	const DCPS::GUID_t &	guid,
		const RtpsDiscovery &	disco,
		DDS::DomainId_t	domainId,
		XTypes::TypeLookupService_rch	tls
	)

Definition at line 378 of file Sedp.cpp.

 {
   type_lookup_service_ = tls;
 
   const OPENDDS_STRING domainStr = DCPS::to_dds_string(domainId);
   const OPENDDS_STRING key = DCPS::GuidConverter(guid).uniqueParticipantId();
 
   // configure one transport
   transport_inst_ = TheTransportRegistry->create_inst(
                        DCPS::TransportRegistry::DEFAULT_INST_PREFIX +
                        OPENDDS_STRING("_SEDPTransportInst_") + key + domainStr,
                        "rtps_udp");
 
   // Be careful to not call any function that causes the transport be
   // to created before the configuration is complete.
 
   // Use a static cast to avoid dependency on the RtpsUdp library
   DCPS::RtpsUdpInst_rch rtps_inst =
       DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   rtps_inst->max_message_size_ = disco.config()->sedp_max_message_size();
   rtps_inst->heartbeat_period_ = disco.config()->sedp_heartbeat_period();
   rtps_inst->nak_response_delay_ = disco.config()->sedp_nak_response_delay();
   rtps_inst->responsive_mode_ = disco.config()->sedp_responsive_mode();
   rtps_inst->send_delay_ = disco.config()->sedp_send_delay();
   rtps_inst->send_buffer_size_ = disco.config()->send_buffer_size();
   rtps_inst->rcv_buffer_size_ = disco.config()->recv_buffer_size();
   rtps_inst->receive_preallocated_message_blocks_ = disco.config()->sedp_receive_preallocated_message_blocks();
   rtps_inst->receive_preallocated_data_blocks_ = disco.config()->sedp_receive_preallocated_data_blocks();
 
   if (disco.sedp_multicast()) {
     // Bind to a specific multicast group
     const u_short mc_port = disco.pb() + disco.dg() * domainId + disco.dx();
 
     ACE_INET_Addr mc_addr = disco.default_multicast_group();
     mc_addr.set_port_number(mc_port);
     rtps_inst->multicast_group_address_ = mc_addr;
 
     rtps_inst->ttl_ = disco.ttl();
     rtps_inst->multicast_interface_ = disco.multicast_interface();
 
   } else {
     rtps_inst->use_multicast_ = false;
   }
 
   rtps_inst->local_address_ = disco.config()->sedp_local_address();
   rtps_inst->advertised_address_ = disco.config()->sedp_advertised_address();
 #ifdef ACE_HAS_IPV6
   rtps_inst->ipv6_local_address_ = disco.config()->ipv6_sedp_local_address();
   rtps_inst->ipv6_advertised_address_ = disco.config()->ipv6_sedp_advertised_address();
 #endif
 
   if (!disco.config()->sedp_fragment_reassembly_timeout().is_zero()) {
     rtps_inst->fragment_reassembly_timeout_ = disco.config()->sedp_fragment_reassembly_timeout();
   }
 
   {
     ACE_GUARD_RETURN(ACE_Thread_Mutex, g, rtps_inst->config_lock_, DDS::RETCODE_PRECONDITION_NOT_MET);
     rtps_inst->rtps_relay_address_ = disco.config()->sedp_rtps_relay_address();
     rtps_inst->use_rtps_relay_ = disco.config()->use_rtps_relay();
     rtps_inst->rtps_relay_only_ = disco.config()->rtps_relay_only();
     rtps_inst->stun_server_address_ = disco.config()->sedp_stun_server_address();
     rtps_inst->use_ice_ = disco.config()->use_ice();
   }
 
   // Create a config
   OPENDDS_STRING config_name = DCPS::TransportRegistry::DEFAULT_INST_PREFIX +
                             OPENDDS_STRING("_SEDP_TransportCfg_") + key +
                             domainStr;
   transport_cfg_ = TheTransportRegistry->create_config(config_name.c_str());
   transport_cfg_->instances_.push_back(transport_inst_);
   transport_cfg_->passive_connect_duration_ =
     static_cast<unsigned long>(disco.config()->sedp_passive_connect_duration().value().get_msec());
 
   rtps_inst->opendds_discovery_default_listener_ = publications_reader_;
   rtps_inst->opendds_discovery_guid_ = guid;
 
   const_cast<bool&>(use_xtypes_) = disco.use_xtypes();
   const_cast<bool&>(use_xtypes_complete_) = disco.use_xtypes_complete();
 
   reactor_task_ = transport_inst_->reactor_task();
   // One should assume that the transport is configured after this
   // point.  Changes to transport_inst_ or rtps_inst after this line
   // may not be reflected.
   ACE_Reactor* reactor = reactor_task_->get_reactor();
   job_queue_ = DCPS::make_rch<DCPS::JobQueue>(reactor);
   event_dispatcher_ = transport_inst_->event_dispatcher();
   type_lookup_init(reactor_task_->interceptor());
 
   // Configure and enable each reader/writer
   const bool reliable = true;
   const bool durable = true;
   const bool nondurable = false;
 
 #ifdef OPENDDS_SECURITY
   const bool besteffort = false;
 #endif
 
   const BuiltinEndpointSet_t bep = spdp_.available_builtin_endpoints();
 #ifdef OPENDDS_SECURITY
   const DDS::Security::ExtendedBuiltinEndpointSet_t xbep =
     spdp_.available_extended_builtin_endpoints();
 #endif
 
   if (bep & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER) {
     publications_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   publications_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 
 #ifdef OPENDDS_SECURITY
   publications_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
   publications_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
   if (bep & DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER) {
     publications_secure_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   publications_secure_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 #endif
 
   if (bep & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER) {
     subscriptions_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   subscriptions_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 
 #ifdef OPENDDS_SECURITY
   subscriptions_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
   subscriptions_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
   if (bep & DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER) {
     subscriptions_secure_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   subscriptions_secure_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 #endif
 
   if (bep & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER) {
     participant_message_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   participant_message_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 
 #ifdef OPENDDS_SECURITY
   participant_message_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
   participant_message_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
   if (bep & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER) {
     participant_message_secure_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   }
   participant_message_secure_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 
   participant_stateless_message_writer_->enable_transport_using_config(besteffort, nondurable, transport_cfg_);
   participant_stateless_message_reader_->enable_transport_using_config(besteffort, nondurable, transport_cfg_);
 
   participant_volatile_message_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
   participant_volatile_message_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
   participant_volatile_message_secure_writer_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   participant_volatile_message_secure_reader_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
 
   dcps_participant_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
   dcps_participant_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
   dcps_participant_secure_writer_->enable_transport_using_config(reliable, durable, transport_cfg_);
   dcps_participant_secure_reader_->enable_transport_using_config(reliable, durable, transport_cfg_);
 #endif
 
   if (bep & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER) {
     type_lookup_request_writer_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
   if (bep & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER) {
     type_lookup_request_reader_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
 
   if (bep & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER) {
     type_lookup_reply_writer_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
   if (bep & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER) {
     type_lookup_reply_reader_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
 
 #ifdef OPENDDS_SECURITY
   if (xbep & DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE) {
     type_lookup_request_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
     type_lookup_request_secure_writer_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
   if (xbep & DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE) {
     type_lookup_request_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
     type_lookup_request_secure_reader_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
 
   if (xbep & DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE) {
     type_lookup_reply_secure_writer_->set_crypto_handles(spdp_.crypto_handle());
     type_lookup_reply_secure_writer_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
   if (xbep & DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE) {
     type_lookup_reply_secure_reader_->set_crypto_handles(spdp_.crypto_handle());
     type_lookup_reply_secure_reader_->enable_transport_using_config(reliable, nondurable, transport_cfg_);
   }
 #endif
 
   max_type_lookup_service_reply_period_ = disco.config()->max_type_lookup_service_reply_period();
 
   return DDS::RETCODE_OK;
 }

◆ init_security()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::init_security	(	DDS::Security::IdentityHandle	id_handle,
		DDS::Security::PermissionsHandle	perm_handle,
		DDS::Security::ParticipantCryptoHandle	crypto_handle
	)

Definition at line 579 of file Sedp.cpp.

 {
   using namespace OpenDDS::Security;
   using namespace DDS::Security;
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
 
   CryptoKeyFactory_var key_factory = spdp_.get_security_config()->get_crypto_key_factory();
   CryptoKeyExchange_var key_exchange = spdp_.get_security_config()->get_crypto_key_exchange();
   AccessControl_var acl = spdp_.get_security_config()->get_access_control();
   Authentication_var auth = spdp_.get_security_config()->get_authentication();
   HandleRegistry_rch handle_registry = spdp_.get_security_config()->get_handle_registry(participant_id_);
 
   set_permissions_handle(perm_handle);
   set_access_control(acl);
   set_crypto_key_factory(key_factory);
   set_crypto_key_exchange(key_exchange);
   set_handle_registry(handle_registry);
   crypto_handle_ = crypto_handle;
 
   // TODO: Handle all exceptions below once error-codes have been defined, etc.
   SecurityException ex = {"", 0, 0};
 
   bool ok = acl->get_participant_sec_attributes(perm_handle, participant_sec_attr_, ex);
   if (ok) {
 
     const EndpointSecurityAttributes default_sec_attr = get_handle_registry()->default_endpoint_security_attributes();
 
     NativeCryptoHandle h = DDS::HANDLE_NIL;
 
     const DDS::PartitionQosPolicy& default_part_qos = TheServiceParticipant->initial_PartitionQosPolicy();
     const DDS::Security::DataTagQosPolicy default_data_tag_qos; // default is empty sequence
 
     // Volatile-Message-Secure
     {
       PropertySeq writer_props(1), reader_props(1);
       writer_props.length(1);
       writer_props[0].name = "dds.sec.builtin_endpoint_name";
       writer_props[0].value = "BuiltinParticipantVolatileMessageSecureWriter";
 
       reader_props.length(1);
       reader_props[0].name = "dds.sec.builtin_endpoint_name";
       reader_props[0].value = "BuiltinParticipantVolatileMessageSecureReader";
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
 
       ok = acl->get_datawriter_sec_attributes(perm_handle, "DCPSParticipantVolatileMessageSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'DCPSParticipantVolatileMessageSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       participant_volatile_message_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t pvms_writer = participant_volatile_message_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(pvms_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "DCPSParticipantVolatileMessageSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'DCPSParticipantVolatileMessageSecure'.")
           ACE_TEXT(" Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       participant_volatile_message_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t pvms_reader = participant_volatile_message_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(pvms_reader, h, dr_sec_attr);
     }
 
     // DCPS-Participant-Message-Secure
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "DCPSParticipantMessageSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'DCPSParticipantMessageSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       participant_message_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t pms_writer = participant_message_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(pms_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "DCPSParticipantMessageSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'DCPSParticipantMessageSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       participant_message_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t pms_reader = participant_message_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(pms_reader, h, dr_sec_attr);
     }
 
     // DCPS-Publications-Secure
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "DCPSPublicationsSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'DCPSPublicationsSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       publications_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_writer = publications_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(ps_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "DCPSPublicationsSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'DCPSPublicationsSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       publications_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_reader = publications_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(ps_reader, h, dr_sec_attr);
     }
 
     // DCPS-Subscriptions-Secure
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "DCPSSubscriptionsSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'DCPSSubscriptionsSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       subscriptions_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t ss_writer = subscriptions_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(ss_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "DCPSSubscriptionsSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'DCPSSubscriptionsSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       subscriptions_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t ss_reader = subscriptions_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(ss_reader, h, dr_sec_attr);
     }
 
     // DCPS-Participants-Secure
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "DCPSParticipantSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'DCPSParticipantSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       dcps_participant_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t dps_writer = dcps_participant_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(dps_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "DCPSParticipantSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'DCPSParticipantSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       dcps_participant_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t dps_reader = dcps_participant_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(dps_reader, h, dr_sec_attr);
     }
 
     // Type Lookup Service Request
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "TypeLookupServiceRequestSecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'TypeLookupServiceRequestSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       type_lookup_request_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_writer = type_lookup_request_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(ps_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "TypeLookupServiceRequestSecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'TypeLookupServiceRequestSecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       type_lookup_request_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_reader = type_lookup_request_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(ps_reader, h, dr_sec_attr);
     }
 
     // Type Lookup Service Reply
     {
       PropertySeq reader_props, writer_props;
 
       EndpointSecurityAttributes dw_sec_attr(default_sec_attr);
       ok = acl->get_datawriter_sec_attributes(perm_handle, "TypeLookupServiceReplySecure",
                                               default_part_qos, default_data_tag_qos, dw_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datawriter_sec_attributes for topic 'TypeLookupServiceReplySecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datawriter(crypto_handle, writer_props, dw_sec_attr, ex);
       type_lookup_reply_secure_writer_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_writer = type_lookup_reply_secure_writer_->get_guid();
       get_handle_registry()->insert_local_datawriter_crypto_handle(ps_writer, h, dw_sec_attr);
 
       EndpointSecurityAttributes dr_sec_attr(default_sec_attr);
       ok = acl->get_datareader_sec_attributes(perm_handle, "TypeLookupServiceReplySecure",
                                               default_part_qos, default_data_tag_qos, dr_sec_attr, ex);
       if (!ok) {
         ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
           ACE_TEXT("Failure calling get_datareader_sec_attributes for topic 'TypeLookupServiceReplySecure'. ")
           ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
         result = DDS::RETCODE_ERROR;
       }
 
       h = key_factory->register_local_datareader(crypto_handle, reader_props, dr_sec_attr, ex);
       type_lookup_reply_secure_reader_->set_crypto_handles(crypto_handle, h);
       const GUID_t ps_reader = type_lookup_reply_secure_reader_->get_guid();
       get_handle_registry()->insert_local_datareader_crypto_handle(ps_reader, h, dr_sec_attr);
     }
 
   } else {
     ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::init_security() - ")
       ACE_TEXT("Failure calling get_participant_sec_attributes. ")
       ACE_TEXT("Security Exception[%d.%d]: %C\n"), ex.code, ex.minor_code, ex.message.in()));
     result = DDS::RETCODE_ERROR;
   }
   return result;
 }

◆ is_expectant_opendds()

bool OpenDDS::RTPS::Sedp::is_expectant_opendds ( const GUID_t & endpoint ) const

privatevirtual

Definition at line 2912 of file Sedp.cpp.

References OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::RTPS::Spdp::is_expectant_opendds(), and spdp_.

Referenced by association_complete_i(), and process_discovered_reader_data().

 {
   GUID_t participant = endpoint;
   participant.entityId = DCPS::ENTITYID_PARTICIPANT;
   return spdp_.is_expectant_opendds(participant);
 }

◆ is_security_enabled()

bool OpenDDS::RTPS::Sedp::is_security_enabled ( )

inlineprotected

Definition at line 1176 of file Sedp.h.

References access_control_, DDS::HANDLE_NIL, and permissions_handle_.

Referenced by add_publication(), add_subscription(), get_remote_type_objects(), match_continue(), process_discovered_reader_data(), process_discovered_writer_data(), remove_publication(), remove_publication_i(), remove_subscription(), remove_subscription_i(), send_type_lookup_request(), should_drop_message(), signal_liveliness(), write_durable_subscription_data(), write_publication_data(), and write_subscription_data().

   {
     return (permissions_handle_ != DDS::HANDLE_NIL) && (access_control_ != 0);
   }

◆ job_queue()

DCPS::JobQueue_rch OpenDDS::RTPS::Sedp::job_queue ( ) const

inline

Definition at line 199 of file Sedp.h.

References append_transport_statistics(), ignore(), and job_queue_.

199 { return job_queue_; }

OpenDDS::RTPS::Sedp::job_queue_

DCPS::JobQueue_rch job_queue_

Definition: Sedp.h:773

◆ local_address()

const DCPS::NetworkAddress & OpenDDS::RTPS::Sedp::local_address ( ) const

Definition at line 928 of file Sedp.cpp.

References OpenDDS::DCPS::static_rchandle_cast(), and transport_inst_.

 {
   DCPS::RtpsUdpInst_rch rtps_inst =
       DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   return rtps_inst->local_address_;
 }

◆ local_has_remote_endpoint_token_i()

bool OpenDDS::RTPS::Sedp::local_has_remote_endpoint_token_i	(	const GUID_t &	local,
		const GUID_t &	remote
	)		const

private

Definition at line 6536 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::crypto_handle_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datareader_security_attributes(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_security_attributes(), DDS::HANDLE_NIL, DDS::Security::EndpointSecurityAttributes::is_payload_protected, DDS::Security::EndpointSecurityAttributes::is_submessage_protected, LM_INFO, OpenDDS::RTPS::Spdp::security_config_, and spdp_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::local_has_remote_endpoint_token_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   if (spdp_.crypto_handle_ == DDS::HANDLE_NIL) {
     return true;
   }
 
   if (is_stateless_or_volatile(local)) {
     // Don't need the token so okay.
     return true;
   }
 
   Security::CryptoKeyExchange_var key_exchange = spdp_.security_config_->get_crypto_key_exchange();
   if (DCPS::GuidConverter(local).isWriter()) {
     const DDS::Security::DatawriterCryptoHandle local_crypto_handle =
       get_handle_registry()->get_local_datawriter_crypto_handle(local);
     if (local_crypto_handle == DDS::HANDLE_NIL) {
       return true;
     }
     const DDS::Security::DatareaderCryptoHandle remote_crypto_handle =
       get_handle_registry()->get_remote_datareader_crypto_handle(remote);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_remote_datareader_security_attributes(remote);
     return !attribs.is_submessage_protected ||
       key_exchange->have_remote_datareader_crypto_tokens(local_crypto_handle, remote_crypto_handle);
   } else {
     const DDS::Security::DatareaderCryptoHandle local_crypto_handle =
       get_handle_registry()->get_local_datareader_crypto_handle(local);
     if (local_crypto_handle == DDS::HANDLE_NIL) {
       return true;
     }
     const DDS::Security::DatawriterCryptoHandle remote_crypto_handle =
       get_handle_registry()->get_remote_datawriter_crypto_handle(remote);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_remote_datawriter_security_attributes(remote);
     return (!attribs.is_submessage_protected && !attribs.is_payload_protected) ||
       key_exchange->have_remote_datawriter_crypto_tokens(local_crypto_handle, remote_crypto_handle);
   }
 }

◆ local_has_remote_participant_token_i()

bool OpenDDS::RTPS::Sedp::local_has_remote_participant_token_i	(	const GUID_t &	local,
		const GUID_t &	remote
	)		const

private

Definition at line 6481 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::crypto_handle_, crypto_handle_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_remote_participant_crypto_handle(), DDS::HANDLE_NIL, LM_INFO, OpenDDS::DCPS::make_id(), OpenDDS::RTPS::Spdp::security_config_, and spdp_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::local_has_remote_participant_token_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   if (spdp_.crypto_handle_ == DDS::HANDLE_NIL) {
     return true;
   }
 
   const GUID_t remote_part = make_id(remote, ENTITYID_PARTICIPANT);
 
   if (is_stateless_or_volatile(local)) {
     // Don't need the token so okay.
     return true;
   }
 
   Security::CryptoKeyExchange_var key_exchange = spdp_.security_config_->get_crypto_key_exchange();
   const DDS::Security::ParticipantCryptoHandle dp_crypto_handle =
     get_handle_registry()->get_remote_participant_crypto_handle(remote_part);
 
   return !key_exchange->have_local_participant_crypto_tokens(crypto_handle_, dp_crypto_handle) ||
     key_exchange->have_remote_participant_crypto_tokens(crypto_handle_, dp_crypto_handle);
 }

◆ make_topic_guid()

GUID_t OpenDDS::RTPS::Sedp::make_topic_guid ( )

inlineprotected

Definition at line 1154 of file Sedp.h.

References assign_topic_key(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::EntityId_t::entityKind, OpenDDS::DCPS::ENTITYKIND_OPENDDS_TOPIC, and participant_id_.

Referenced by assert_topic(), process_discovered_reader_data(), and process_discovered_writer_data().

   {
     GUID_t guid;
     guid = participant_id_;
     guid.entityId.entityKind = DCPS::ENTITYKIND_OPENDDS_TOPIC;
     assign_topic_key(guid);
     return guid;
   }

◆ match()

void OpenDDS::RTPS::Sedp::match	(	const GUID_t &	writer,
		const GUID_t &	reader
	)

protected

Definition at line 6824 of file Sedp.cpp.

References ACE_DEBUG, OpenDDS::DCPS::DCPS_debug_level, discovered_publications_, discovered_subscriptions_, OpenDDS::XTypes::TypeIdentifier::kind(), LM_DEBUG, local_publications_, local_subscriptions_, match_continue(), OpenDDS::XTypes::TypeInformation::minimal, need_minimal_and_or_complete_types(), request_type_objects(), OpenDDS::XTypes::TK_NONE, OpenDDS::XTypes::TypeIdentifierWithSize::type_id, OpenDDS::XTypes::TypeIdentifierWithDependencies::typeid_with_size, and use_xtypes_.

Referenced by match_endpoints().

 {
   if (DCPS_debug_level >= 4) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: w: %C r: %C\n",
       LogGuid(writer).c_str(), LogGuid(reader).c_str()));
   }
 
   // 1. collect type info about the writer, which may be local or discovered
   XTypes::TypeInformation* writer_type_info = 0;
 
   const LocalPublicationIter lpi = local_publications_.find(writer);
   DiscoveredPublicationIter dpi;
   bool writer_local = false;
   if (lpi != local_publications_.end()) {
     writer_local = true;
     writer_type_info = &lpi->second.type_info_;
   } else if ((dpi = discovered_publications_.find(writer))
              != discovered_publications_.end()) {
     writer_type_info = &dpi->second.type_info_;
   } else {
     if (DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: Undiscovered Writer\n"));
     }
     return; // Possible and ok, since lock is released
   }
 
   // 2. collect type info about the reader, which may be local or discovered
   XTypes::TypeInformation* reader_type_info = 0;
 
   const LocalSubscriptionIter lsi = local_subscriptions_.find(reader);
   DiscoveredSubscriptionIter dsi;
   bool reader_local = false;
   if (lsi != local_subscriptions_.end()) {
     reader_local = true;
     reader_type_info = &lsi->second.type_info_;
   } else if ((dsi = discovered_subscriptions_.find(reader))
              != discovered_subscriptions_.end()) {
     reader_type_info = &dsi->second.type_info_;
   } else {
     if (DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: Undiscovered Reader\n"));
     }
     return; // Possible and ok, since lock is released
   }
 
   // if the type object is not in cache, send RPC request
   // NOTE(sonndinh): Is it possible for a discovered endpoint to include only the "complete"
   // part in its TypeInformation? If it's possible, then we may need to handle that case, i.e.,
   // request only the remote complete TypeObject (if it's not already in the cache).
   // The following code assumes when the "minimal" part is not included in the discovered
   // endpoint's TypeInformation, then the "complete" part also is not included.
   bool request = false;
   bool need_minimal, need_complete;
   if ((writer_type_info->minimal.typeid_with_size.type_id.kind() != XTypes::TK_NONE) &&
       (reader_type_info->minimal.typeid_with_size.type_id.kind() != XTypes::TK_NONE)) {
     if (!writer_local && reader_local) {
       if (need_minimal_and_or_complete_types(writer_type_info, need_minimal, need_complete)) {
         if (DCPS_debug_level >= 4) {
           ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: "
             "Need to get type objects from remote writer\n"));
         }
         request = true;
       }
     } else if (!reader_local && writer_local) {
       if (need_minimal_and_or_complete_types(reader_type_info, need_minimal, need_complete)) {
         if (DCPS_debug_level >= 4) {
           ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: "
             "Need to get type objects from remote reader\n"));
         }
         request = true;
       }
     }
   } else if (reader_local && !writer_local && use_xtypes_ &&
              writer_type_info->minimal.typeid_with_size.type_id.kind() != XTypes::TK_NONE) {
     // We are a recorder trying to associate with a remote xtypes writer
     if (need_minimal_and_or_complete_types(writer_type_info, need_minimal, need_complete)) {
       if (DCPS_debug_level >= 4) {
         ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match: "
           "Need to get type objects from remote reader for recorder\n"));
       }
       request = true;
     }
   }
 
   if (request) {
     request_type_objects(
       reader_local ? writer_type_info : reader_type_info,
       MatchingPair(reader, writer, reader_local),
 #ifdef OPENDDS_SECURITY
       reader_local ?
         lsi->second.security_attribs_.base.is_discovery_protected :
         lpi->second.security_attribs_.base.is_discovery_protected,
 #else
       false,
 #endif
       need_minimal, need_complete);
   } else {
     match_continue(writer, reader);
   }
 }

◆ match_continue()

void OpenDDS::RTPS::Sedp::match_continue	(	const GUID_t &	writer,
		const GUID_t &	reader
	)

protected

Definition at line 7049 of file Sedp.cpp.

Referenced by match(), and OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_type_lookup_reply().

 {
   if (DCPS_debug_level >= 4) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match_continue: w: %C r: %C\n",
       LogGuid(writer).c_str(), LogGuid(reader).c_str()));
   }
 
   // 0. For discovered endpoints, we'll have the QoS info in the form of the
   // publication or subscription BIT data which doesn't use the same structures
   // for QoS.  In those cases we can copy the individual QoS policies to temp
   // QoS structs:
   DDS::DataWriterQos tempDwQos;
   DDS::PublisherQos tempPubQos;
   DDS::DataReaderQos tempDrQos;
   DDS::SubscriberQos tempSubQos;
   DCPS::ContentFilterProperty_t tempCfp;
 
   DiscoveredPublicationIter dpi = discovered_publications_.find(writer);
   DiscoveredSubscriptionIter dsi = discovered_subscriptions_.find(reader);
   if (dpi != discovered_publications_.end() && dsi != discovered_subscriptions_.end()) {
     // This is a discovered/discovered match, nothing for us to do
     return;
   }
 
   // 1. Collect details about the writer, which may be local or discovered
   const DDS::DataWriterQos* dwQos = 0;
   const DDS::PublisherQos* pubQos = 0;
   DCPS::TransportLocatorSeq* wTls = 0;
   ACE_CDR::ULong wTransportContext = 0;
   XTypes::TypeInformation* writer_type_info = 0;
   String topic_name;
   DCPS::MonotonicTime_t writer_participant_discovered_at;
 
   const LocalPublicationIter lpi = local_publications_.find(writer);
   bool writer_local = false, already_matched = false;
   if (lpi != local_publications_.end()) {
     writer_local = true;
     dwQos = &lpi->second.qos_;
     pubQos = &lpi->second.publisher_qos_;
     wTls = &lpi->second.trans_info_;
     wTransportContext = lpi->second.transport_context_;
     already_matched = lpi->second.matched_endpoints_.count(reader);
     writer_type_info = &lpi->second.type_info_;
     topic_name = topic_names_[lpi->second.topic_id_];
     writer_participant_discovered_at = lpi->second.participant_discovered_at_;
   } else if (dpi != discovered_publications_.end()) {
     wTls = &dpi->second.writer_data_.writerProxy.allLocators;
     wTransportContext = dpi->second.transport_context_;
     writer_type_info = &dpi->second.type_info_;
     topic_name = dpi->second.get_topic_name();
     writer_participant_discovered_at = dpi->second.participant_discovered_at_;
 
     const DDS::PublicationBuiltinTopicData& bit =
       dpi->second.writer_data_.ddsPublicationData;
     tempDwQos.durability = bit.durability;
     tempDwQos.durability_service = bit.durability_service;
     tempDwQos.deadline = bit.deadline;
     tempDwQos.latency_budget = bit.latency_budget;
     tempDwQos.liveliness = bit.liveliness;
     tempDwQos.reliability = bit.reliability;
     tempDwQos.destination_order = bit.destination_order;
     tempDwQos.history = TheServiceParticipant->initial_HistoryQosPolicy();
     tempDwQos.resource_limits =
       TheServiceParticipant->initial_ResourceLimitsQosPolicy();
     tempDwQos.transport_priority =
       TheServiceParticipant->initial_TransportPriorityQosPolicy();
     tempDwQos.lifespan = bit.lifespan;
     tempDwQos.user_data = bit.user_data;
     tempDwQos.ownership = bit.ownership;
     tempDwQos.ownership_strength = bit.ownership_strength;
     tempDwQos.writer_data_lifecycle =
       TheServiceParticipant->initial_WriterDataLifecycleQosPolicy();
     tempDwQos.representation = bit.representation;
     dwQos = &tempDwQos;
 
     tempPubQos.presentation = bit.presentation;
     tempPubQos.partition = bit.partition;
     tempPubQos.group_data = bit.group_data;
     tempPubQos.entity_factory =
       TheServiceParticipant->initial_EntityFactoryQosPolicy();
     pubQos = &tempPubQos;
 
     populate_transport_locator_sequence(*wTls, dpi, writer);
   } else {
     return; // Possible and ok, since lock is released
   }
 
   // 2. Collect details about the reader, which may be local or discovered
   const DDS::DataReaderQos* drQos = 0;
   const DDS::SubscriberQos* subQos = 0;
   DCPS::TransportLocatorSeq* rTls = 0;
   ACE_CDR::ULong rTransportContext = 0;
 #ifndef OPENDDS_NO_CONTENT_FILTERED_TOPIC
   const DCPS::ContentFilterProperty_t* cfProp = 0;
 #endif
   XTypes::TypeInformation* reader_type_info = 0;
   DCPS::MonotonicTime_t reader_participant_discovered_at;
 
   const LocalSubscriptionIter lsi = local_subscriptions_.find(reader);
   bool reader_local = false;
   if (lsi != local_subscriptions_.end()) {
     reader_local = true;
     drQos = &lsi->second.qos_;
     subQos = &lsi->second.subscriber_qos_;
     rTls = &lsi->second.trans_info_;
     rTransportContext = lsi->second.transport_context_;
     reader_type_info = &lsi->second.type_info_;
     if (lsi->second.filterProperties.filterExpression[0] != 0) {
       tempCfp.filterExpression = lsi->second.filterProperties.filterExpression;
       tempCfp.expressionParameters = lsi->second.filterProperties.expressionParameters;
     }
 #ifndef OPENDDS_NO_CONTENT_FILTERED_TOPIC
     cfProp = &tempCfp;
 #endif
     if (!already_matched) {
       already_matched = lsi->second.matched_endpoints_.count(writer);
     }
     reader_participant_discovered_at = lsi->second.participant_discovered_at_;
   } else if (dsi != discovered_subscriptions_.end()) {
     rTls = &dsi->second.reader_data_.readerProxy.allLocators;
 
     populate_transport_locator_sequence(*rTls, dsi, reader);
     rTransportContext = dsi->second.transport_context_;
 
     const DDS::SubscriptionBuiltinTopicData& bit =
       dsi->second.reader_data_.ddsSubscriptionData;
     tempDrQos.durability = bit.durability;
     tempDrQos.deadline = bit.deadline;
     tempDrQos.latency_budget = bit.latency_budget;
     tempDrQos.liveliness = bit.liveliness;
     tempDrQos.reliability = bit.reliability;
     tempDrQos.destination_order = bit.destination_order;
     tempDrQos.history = TheServiceParticipant->initial_HistoryQosPolicy();
     tempDrQos.resource_limits =
       TheServiceParticipant->initial_ResourceLimitsQosPolicy();
     tempDrQos.user_data = bit.user_data;
     tempDrQos.ownership = bit.ownership;
     tempDrQos.time_based_filter = bit.time_based_filter;
     tempDrQos.reader_data_lifecycle =
       TheServiceParticipant->initial_ReaderDataLifecycleQosPolicy();
     tempDrQos.representation = bit.representation;
     tempDrQos.type_consistency = bit.type_consistency;
     drQos = &tempDrQos;
 
     tempSubQos.presentation = bit.presentation;
     tempSubQos.partition = bit.partition;
     tempSubQos.group_data = bit.group_data;
     tempSubQos.entity_factory =
       TheServiceParticipant->initial_EntityFactoryQosPolicy();
     subQos = &tempSubQos;
 
 #ifndef OPENDDS_NO_CONTENT_FILTERED_TOPIC
     cfProp = &dsi->second.reader_data_.contentFilterProperty;
 #endif
     reader_type_info = &dsi->second.type_info_;
     reader_participant_discovered_at = dsi->second.participant_discovered_at_;
   } else {
     return; // Possible and ok, since lock is released
   }
 
   // 3. Perform type consistency check (XTypes 1.3, Section 7.6.3.4.2)
   bool consistent = false;
 
   DCPS::TopicDetailsMap::iterator td_iter = topics_.find(topic_name);
   if (td_iter == topics_.end()) {
     ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) Sedp::match_continue - ERROR ")
               ACE_TEXT("Didn't find topic for consistency check\n")));
     return;
   } else {
     const XTypes::TypeIdentifier& writer_type_id =
       writer_type_info->minimal.typeid_with_size.type_id;
     const XTypes::TypeIdentifier& reader_type_id =
       reader_type_info->minimal.typeid_with_size.type_id;
     if (writer_type_id.kind() != XTypes::TK_NONE && reader_type_id.kind() != XTypes::TK_NONE) {
       if (!writer_local || !reader_local) {
         DCPS::Encoding::Kind encoding_kind;
         if (tempDwQos.representation.value.length() > 0 &&
             DCPS::repr_to_encoding_kind(tempDwQos.representation.value[0], encoding_kind) &&
             encoding_kind == DCPS::Encoding::KIND_XCDR1) {
           const XTypes::TypeFlag extensibility_mask = XTypes::IS_APPENDABLE;
           if (type_lookup_service_->extensibility(extensibility_mask, writer_type_id)) {
             if (OpenDDS::DCPS::DCPS_debug_level) {
               ACE_DEBUG((LM_WARNING, "(%P|%t) WARNING: "
                 "Sedp::match_continue: "
                 "Encountered unsupported combination of XCDR1 encoding and appendable "
                 "extensibility\n"));
             }
           }
         }
       }
 
       XTypes::TypeConsistencyAttributes type_consistency;
       type_consistency.ignore_sequence_bounds = drQos->type_consistency.ignore_sequence_bounds;
       type_consistency.ignore_string_bounds = drQos->type_consistency.ignore_string_bounds;
       type_consistency.ignore_member_names = drQos->type_consistency.ignore_member_names;
       type_consistency.prevent_type_widening = drQos->type_consistency.prevent_type_widening;
       XTypes::TypeAssignability ta(type_lookup_service_, type_consistency);
 
       if (drQos->type_consistency.kind == DDS::ALLOW_TYPE_COERCION) {
         consistent = ta.assignable(reader_type_id, writer_type_id);
       } else {
         // The two types must be equivalent for DISALLOW_TYPE_COERCION
         consistent = reader_type_id == writer_type_id;
         if (!consistent && DCPS::DCPS_debug_level >= 4) {
           ACE_DEBUG((LM_WARNING, "(%P|%t) Sedp::match_continue: will not match because type "
             "ids must be the same when using DISALLOW_TYPE_COERCION\n"));
         }
       }
     } else {
       if (drQos->type_consistency.force_type_validation) {
         // Cannot do type validation since not both TypeObjects are available
         consistent = false;
         if (DCPS::DCPS_debug_level >= 4) {
           ACE_DEBUG((LM_WARNING, "(%P|%t) Sedp::match_continue: will not match because "
             "force_type_validation is true, but TypeObjects are not available\n"));
         }
       } else {
         // Fall back to matching type names
         String writer_type_name;
         String reader_type_name;
         if (writer_local) {
           writer_type_name = td_iter->second.local_data_type_name();
         } else {
           writer_type_name = dpi->second.get_type_name();
         }
         if (reader_local) {
           reader_type_name = td_iter->second.local_data_type_name();
         } else {
           reader_type_name = dsi->second.get_type_name();
         }
         consistent = reader_type_name.empty() || writer_type_name == reader_type_name;
       }
     }
 
     if (!consistent) {
       td_iter->second.increment_inconsistent();
       if (DCPS::DCPS_debug_level) {
         ACE_DEBUG((LM_WARNING,
                   ACE_TEXT("(%P|%t) Sedp::match_continue - WARNING ")
                   ACE_TEXT("Data types of topic %C does not match (inconsistent)\n"),
                   topic_name.c_str()));
       }
       return;
     }
   }
 
   // 4. Check transport and QoS compatibility
 
   // Copy entries from local publication and local subscription maps
   // prior to releasing lock
   DCPS::DataWriterCallbacks_wrch dwr;
   DCPS::DataReaderCallbacks_wrch drr;
   if (writer_local) {
     dwr = lpi->second.publication_;
     OPENDDS_ASSERT(lpi->second.publication_);
     OPENDDS_ASSERT(dwr);
   }
   if (reader_local) {
     drr = lsi->second.subscription_;
     OPENDDS_ASSERT(lsi->second.subscription_);
     OPENDDS_ASSERT(drr);
   }
 
   DCPS::IncompatibleQosStatus writerStatus = {0, 0, 0, DDS::QosPolicyCountSeq()};
   DCPS::IncompatibleQosStatus readerStatus = {0, 0, 0, DDS::QosPolicyCountSeq()};
 
   if (compatibleQOS(&writerStatus, &readerStatus, *wTls, *rTls,
       dwQos, drQos, pubQos, subQos)) {
 
     bool call_writer = false, call_reader = false;
 
     if (writer_local) {
       call_writer = lpi->second.matched_endpoints_.insert(reader).second;
       dwr = lpi->second.publication_;
       if (!reader_local) {
         dsi->second.matched_endpoints_.insert(writer);
       }
     }
     if (reader_local) {
       call_reader = lsi->second.matched_endpoints_.insert(writer).second;
       drr = lsi->second.subscription_;
       if (!writer_local) {
         dpi->second.matched_endpoints_.insert(reader);
       }
     }
 
     if (writer_local && !reader_local) {
       add_assoc_i(writer, lpi->second, reader, dsi->second);
     }
     if (reader_local && !writer_local) {
       add_assoc_i(reader, lsi->second, writer, dpi->second);
     }
 
     if (!call_writer && !call_reader) {
       return; // nothing more to do
     }
 
     // Copy reader and writer association data prior to releasing lock
     WriterAssociationRecord_rch war;
     if (call_writer) {
       war = make_rch<WriterAssociationRecord>(dwr, writer, DCPS::ReaderAssociation());
       DCPS::ReaderAssociation& ra = const_cast<DCPS::ReaderAssociation&>(war->reader_association_);
       ra.readerTransInfo = *rTls;
       populate_origination_locator(reader, ra.readerDiscInfo);
       ra.transportContext = rTransportContext;
       ra.readerId = reader;
       ra.subQos = *subQos;
       ra.readerQos = *drQos;
 #ifndef OPENDDS_NO_CONTENT_FILTERED_TOPIC
       ra.filterClassName = cfProp->filterClassName;
       ra.filterExpression = cfProp->filterExpression;
       ra.exprParams = cfProp->expressionParameters;
 #endif
       XTypes::serialize_type_info(*reader_type_info, ra.serializedTypeInfo);
       ra.participantDiscoveredAt = writer_participant_discovered_at;
     }
 
     ReaderAssociationRecord_rch rar;
     if (call_reader) {
       rar = make_rch<ReaderAssociationRecord>(drr, reader, DCPS::WriterAssociation());
       DCPS::WriterAssociation& wa = const_cast<DCPS::WriterAssociation&>(rar->writer_association_);
       wa.writerTransInfo = *wTls;
       populate_origination_locator(writer, wa.writerDiscInfo);
       wa.transportContext = wTransportContext;
       wa.writerId = writer;
       wa.pubQos = *pubQos;
       wa.writerQos = *dwQos;
       XTypes::serialize_type_info(*writer_type_info, wa.serializedTypeInfo);
       wa.participantDiscoveredAt = writer_participant_discovered_at;
     }
 
 #ifdef OPENDDS_SECURITY
     if (is_security_enabled()) {
       match_continue_security_enabled(writer, reader, call_writer, call_reader);
     }
 #endif
 
     if (call_reader && call_writer) {
       // Associate immediately.
       event_dispatcher_->dispatch(DCPS::make_rch<ReaderAddAssociation>(rar));
       event_dispatcher_->dispatch(DCPS::make_rch<WriterAddAssociation>(war));
 
 #ifndef OPENDDS_SAFETY_PROFILE
       if (use_xtypes_complete_ && reader_type_info->complete.typeid_with_size.type_id.kind() == XTypes::TK_NONE) {
         // Reader is a local recorder using complete types
         DCPS::DataReaderCallbacks_rch lock = rar->callbacks_.lock();
         OpenDDS::DCPS::RecorderImpl* ri = dynamic_cast<OpenDDS::DCPS::RecorderImpl*>(lock.in());
         if (ri) {
           XTypes::TypeInformation type_info;
           if (XTypes::deserialize_type_info(type_info, rar->writer_association_.serializedTypeInfo)) {
             ri->add_to_dynamic_type_map(rar->writer_id(), type_info.complete.typeid_with_size.type_id);
           }
         }
       }
 #endif
 
     } else if (call_reader) {
 #ifndef OPENDDS_SAFETY_PROFILE
       if (use_xtypes_complete_ && reader_type_info->complete.typeid_with_size.type_id.kind() == XTypes::TK_NONE) {
         // Reader is a local recorder using complete types
         DCPS::DataReaderCallbacks_rch lock = rar->callbacks_.lock();
         OpenDDS::DCPS::RecorderImpl* ri = dynamic_cast<OpenDDS::DCPS::RecorderImpl*>(lock.in());
         if (ri) {
           XTypes::TypeInformation type_info;
           if (XTypes::deserialize_type_info(type_info, rar->writer_association_.serializedTypeInfo)) {
             ri->add_to_dynamic_type_map(rar->writer_id(), type_info.complete.typeid_with_size.type_id);
           }
         }
       }
 #endif
       Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(make_id(writer, ENTITYID_PARTICIPANT));
       if (iter != spdp_.participants_.end()) {
         iter->second.reader_pending_records_.push_back(rar);
         process_association_records_i(iter->second);
       }
     } else if (call_writer) {
       Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(make_id(reader, ENTITYID_PARTICIPANT));
       if (iter != spdp_.participants_.end()) {
         iter->second.writer_pending_records_.push_back(war);
         process_association_records_i(iter->second);
       }
     }
 
   } else if (already_matched) { // break an existing association
     if (writer_local) {
       lpi->second.matched_endpoints_.erase(reader);
       lpi->second.remote_expectant_opendds_associations_.erase(reader);
       if (dsi != discovered_subscriptions_.end()) {
         dsi->second.matched_endpoints_.erase(writer);
       }
     }
     if (reader_local) {
       lsi->second.matched_endpoints_.erase(writer);
       lsi->second.remote_expectant_opendds_associations_.erase(writer);
       if (dpi != discovered_publications_.end()) {
         dpi->second.matched_endpoints_.erase(reader);
       }
     }
     if (writer_local && !reader_local) {
       remove_assoc_i(writer, lpi->second, reader);
     }
     if (reader_local && !writer_local) {
       remove_assoc_i(reader, lsi->second, writer);
     }
     if (writer_local) {
       cleanup_writer_association(dwr, writer, reader);
     }
     if (reader_local) {
       cleanup_reader_association(drr, reader, writer);
     }
   } else { // something was incompatible
     if (writer_local && writerStatus.count_since_last_send) {
       if (DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::match_continue - ")
                    ACE_TEXT("writer incompatible\n")));
       }
       DCPS::DataWriterCallbacks_rch dwr_lock = dwr.lock();
       if (dwr_lock) {
         dwr_lock->update_incompatible_qos(writerStatus);
       }
     }
     if (reader_local && readerStatus.count_since_last_send) {
       if (DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::match_continue - ")
                    ACE_TEXT("reader incompatible\n")));
       }
       DCPS::DataReaderCallbacks_rch drr_lock = drr.lock();
       if (drr_lock) {
         drr_lock->update_incompatible_qos(readerStatus);
       }
     }
   }
 }

◆ match_continue_security_enabled()

void OpenDDS::RTPS::Sedp::match_continue_security_enabled	(	const GUID_t &	writer,
		const GUID_t &	reader,
		bool	call_writer,
		bool	call_reader
	)

protected

Definition at line 7570 of file Sedp.cpp.

References ACE_ERROR, ACE_TEXT(), DDS::Security::SecurityException::code, create_and_send_datareader_crypto_tokens(), create_and_send_datawriter_crypto_tokens(), generate_remote_matched_reader_crypto_handle(), generate_remote_matched_writer_crypto_handle(), get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datareader_security_attributes(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datawriter_security_attributes(), DDS::HANDLE_NIL, DDS::Security::EndpointSecurityAttributes::is_payload_protected, DDS::Security::EndpointSecurityAttributes::is_submessage_protected, LM_ERROR, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, pending_remote_reader_crypto_tokens_, and pending_remote_writer_crypto_tokens_.

Referenced by match_continue().

 {
   DDS::Security::CryptoKeyExchange_var keyexg = get_crypto_key_exchange();
   if (call_reader && !call_writer) {
     const DDS::Security::DatareaderCryptoHandle drch =
       get_handle_registry()->get_local_datareader_crypto_handle(reader);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_local_datareader_security_attributes(reader);
 
     // It might not exist due to security attributes, and that's OK
     if (drch != DDS::HANDLE_NIL) {
       DDS::Security::DatawriterCryptoHandle dwch =
         generate_remote_matched_writer_crypto_handle(writer, reader);
       DatawriterCryptoTokenSeqMap::iterator t_iter =
         pending_remote_writer_crypto_tokens_.find(writer);
       if (t_iter != pending_remote_writer_crypto_tokens_.end()) {
         DDS::Security::SecurityException se;
         if (!keyexg->set_remote_datawriter_crypto_tokens(drch, dwch, t_iter->second, se)) {
           ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
             ACE_TEXT("DiscoveryBase::match_continue_security_enabled: ")
             ACE_TEXT("Unable to set pending remote datawriter crypto tokens with ")
             ACE_TEXT("crypto key exchange plugin. Security Exception[%d.%d]: %C\n"),
               se.code, se.minor_code, se.message.in()));
         }
         pending_remote_writer_crypto_tokens_.erase(t_iter);
       }
       // Yes, this is different for remote datawriters than readers (see 8.8.9.3 vs 8.8.9.2)
       if (attribs.is_submessage_protected) {
         create_and_send_datareader_crypto_tokens(drch, reader, dwch, writer);
       }
     }
   }
 
   if (call_writer && !call_reader) {
     const DDS::Security::DatawriterCryptoHandle dwch =
       get_handle_registry()->get_local_datawriter_crypto_handle(writer);
     const DDS::Security::EndpointSecurityAttributes attribs =
       get_handle_registry()->get_local_datawriter_security_attributes(writer);
 
     // It might not exist due to security attributes, and that's OK
     if (dwch != DDS::HANDLE_NIL) {
       DDS::Security::DatareaderCryptoHandle drch =
         generate_remote_matched_reader_crypto_handle(reader, writer,
                                                      relay_only_readers_.count(reader));
       DatareaderCryptoTokenSeqMap::iterator t_iter =
         pending_remote_reader_crypto_tokens_.find(reader);
       if (t_iter != pending_remote_reader_crypto_tokens_.end()) {
         DDS::Security::SecurityException se;
         if (!keyexg->set_remote_datareader_crypto_tokens(dwch, drch, t_iter->second, se)) {
           ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: ")
             ACE_TEXT("DiscoveryBase::match_continue_security_enabled: ")
             ACE_TEXT("Unable to set pending remote datareader crypto tokens with crypto ")
             ACE_TEXT("key exchange plugin. Security Exception[%d.%d]: %C\n"),
               se.code, se.minor_code, se.message.in()));
         }
         pending_remote_reader_crypto_tokens_.erase(t_iter);
       }
       if (attribs.is_submessage_protected || attribs.is_payload_protected) {
         create_and_send_datawriter_crypto_tokens(dwch, writer, drch, reader);
       }
     }
   }
 }

◆ match_endpoints()

void OpenDDS::RTPS::Sedp::match_endpoints	(	GUID_t	repoId,
		const DCPS::TopicDetails &	td,
		bool	remove = `false`
	)

protected

Definition at line 6673 of file Sedp.cpp.

References ACE_DEBUG, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::TopicDetails::discovered_publications(), OpenDDS::DCPS::TopicDetails::discovered_subscriptions(), OpenDDS::DCPS::equal_guid_prefixes(), OpenDDS::DCPS::GuidConverter::isReader(), LM_DEBUG, OpenDDS::DCPS::TopicDetails::local_publications(), OpenDDS::DCPS::TopicDetails::local_subscriptions(), match(), participant_id_, and remove_assoc().

Referenced by add_publication(), add_subscription(), assign_topic_key(), ignore(), process_discovered_reader_data(), process_discovered_writer_data(), remove_entities_belonging_to(), remove_publication(), remove_subscription(), update_publication_qos(), and update_subscription_qos().

 {
   if (DCPS_debug_level >= 4) {
     ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::match_endpoints %C%C\n",
       remove ? "remove " : "", LogGuid(repoId).c_str()));
   }
 
   const bool reader = DCPS::GuidConverter(repoId).isReader();
   // Copy the endpoint set - lock can be released in match()
   RepoIdSet local_endpoints;
   RepoIdSet discovered_endpoints;
   if (reader) {
     local_endpoints = td.local_publications();
     discovered_endpoints = td.discovered_publications();
   } else {
     local_endpoints = td.local_subscriptions();
     discovered_endpoints = td.discovered_subscriptions();
   }
 
   const bool is_remote = !equal_guid_prefixes(repoId, participant_id_);
   if (is_remote && local_endpoints.empty()) {
     // Nothing to match.
     return;
   }
 
   for (RepoIdSet::const_iterator iter = local_endpoints.begin();
        iter != local_endpoints.end(); ++iter) {
     // check to make sure it's a Reader/Writer or Writer/Reader match
     if (DCPS::GuidConverter(*iter).isReader() != reader) {
       if (remove) {
         remove_assoc(*iter, repoId);
       } else {
         match(reader ? *iter : repoId, reader ? repoId : *iter);
       }
     }
   }
 
   // Remote/remote matches are a waste of time
   if (is_remote) {
     return;
   }
 
   for (RepoIdSet::const_iterator iter = discovered_endpoints.begin();
        iter != discovered_endpoints.end(); ++iter) {
     // check to make sure it's a Reader/Writer or Writer/Reader match
     if (DCPS::GuidConverter(*iter).isReader() != reader) {
       if (remove) {
         remove_assoc(*iter, repoId);
       } else {
         match(reader ? *iter : repoId, reader ? repoId : *iter);
       }
     }
   }
 }

◆ multicast_group()

const DCPS::NetworkAddress & OpenDDS::RTPS::Sedp::multicast_group ( ) const

Definition at line 946 of file Sedp.cpp.

References OpenDDS::DCPS::static_rchandle_cast(), and transport_inst_.

 {
   DCPS::RtpsUdpInst_rch rtps_inst =
       DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   return rtps_inst->multicast_group_address_;
 }

◆ multicast_locators()

DCPS::LocatorSeq OpenDDS::RTPS::Sedp::multicast_locators ( ) const

Definition at line 920 of file Sedp.cpp.

References OpenDDS::DCPS::CONNINFO_MULTICAST, OpenDDS::DCPS::TransportInst::populate_locator(), transport_inst_, and OpenDDS::RTPS::transport_locator_to_locator_seq().

 {
   DCPS::TransportLocator trans_info;
   transport_inst_->populate_locator(trans_info, DCPS::CONNINFO_MULTICAST);
   return transport_locator_to_locator_seq(trans_info);
 }

◆ need_minimal_and_or_complete_types()

bool OpenDDS::RTPS::Sedp::need_minimal_and_or_complete_types	(	const XTypes::TypeInformation *	type_info,
		bool &	need_minimal,
		bool &	need_complete
	)		const

protected

Definition at line 6964 of file Sedp.cpp.

References OpenDDS::XTypes::TypeInformation::complete, OpenDDS::XTypes::TypeIdentifier::kind(), OpenDDS::XTypes::TypeInformation::minimal, OpenDDS::XTypes::TK_NONE, OpenDDS::XTypes::TypeIdentifierWithSize::type_id, type_lookup_service_, OpenDDS::XTypes::TypeIdentifierWithDependencies::typeid_with_size, and use_xtypes_complete_.

Referenced by match().

 {
   need_minimal = type_lookup_service_ &&
     !type_lookup_service_->type_object_in_cache(type_info->minimal.typeid_with_size.type_id);
 
   need_complete = use_xtypes_complete_ && type_lookup_service_ &&
     type_info->complete.typeid_with_size.type_id.kind() != XTypes::TK_NONE &&
     !type_lookup_service_->type_object_in_cache(type_info->complete.typeid_with_size.type_id);
 
   return need_minimal || need_complete;
 }

◆ notify_liveliness()

void OpenDDS::RTPS::Sedp::notify_liveliness ( const ParticipantMessageData & pmd )

private

This is a function to unify the notification of liveliness within RTPS The local participant map is checked for associated entities and then they are notified of liveliness if their QoS is compatible

Definition at line 2671 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::AUTOMATIC_LIVELINESS_QOS, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::equal_guid_prefixes(), LM_DEBUG, local_subscriptions_, OpenDDS::DCPS::make_part_guid(), OpenDDS::DCPS::make_unknown_guid(), DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE, and OpenDDS::RTPS::ParticipantMessageData::participantGuid.

Referenced by data_received(), received_participant_message_data_secure(), and write_participant_message_data().

 {
   const GUID_t& guid = pmd.participantGuid;
   const GUID_t guid_participant = make_part_guid(guid);
   // Clear the entityId so lower bound will work.
   const GUID_t prefix = make_unknown_guid(pmd.participantGuid);
   const bool is_automatic = PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE != pmd.participantGuid.entityId;
   if (DCPS::DCPS_debug_level >= 8) {
     ACE_DEBUG((LM_DEBUG,
                ACE_TEXT("(%P|%t) Sedp::notify_liveliness: Notifying Liveliness, %C\n"),
                DCPS::LogGuid(guid).c_str()));
   }
 
   for (LocalSubscriptionMap::const_iterator sub_pos = local_subscriptions_.begin(),
          sub_limit = local_subscriptions_.end();
        sub_pos != sub_limit; ++sub_pos) {
     const DCPS::RepoIdSet::const_iterator pos =
       sub_pos->second.matched_endpoints_.lower_bound(prefix);
     if (pos != sub_pos->second.matched_endpoints_.end() &&
         DCPS::equal_guid_prefixes(*pos, prefix)) {
       DCPS::DataReaderCallbacks_rch sl = sub_pos->second.subscription_.lock();
       if (sl) {
         if (sub_pos->second.qos_.liveliness.kind == ::DDS::AUTOMATIC_LIVELINESS_QOS && is_automatic) {
           sl->signal_liveliness(guid_participant);
         } else if ((sub_pos->second.qos_.liveliness.kind == ::DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
                    || sub_pos->second.qos_.liveliness.kind == ::DDS::AUTOMATIC_LIVELINESS_QOS) && !is_automatic) {
           sl->signal_liveliness(guid_participant);
         }
       }
     }
   }
 }

◆ OPENDDS_MAP() [1/2]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP	(	SequenceNumber	,
		TypeIdOrigSeqNumber
	)

private

Referenced by OpenDDS::RTPS::Sedp::Writer::get_seq(), and OpenDDS::RTPS::Sedp::MatchingPair::operator<().

◆ OPENDDS_MAP() [2/2]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP	(	MatchingPair	,
		MatchingData
	)

protected

◆ OPENDDS_MAP_CMP() [1/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		DiscoveredSubscription	,
		GUID_tKeyLessThan
	)

private

Referenced by has_dcps_key(), purge_dead_topic(), transport_inst(), and update_topic_qos().

◆ OPENDDS_MAP_CMP() [2/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		DiscoveredPublication	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MAP_CMP() [3/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		LocalPublication	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MAP_CMP() [4/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		LocalSubscription	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MAP_CMP() [5/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		String	,
		GUID_tKeyLessThan
	)

private

◆ OPENDDS_MAP_CMP() [6/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		DDS::Security::DatareaderCryptoTokenSeq	,
		GUID_tKeyLessThan
	)

protected

◆ OPENDDS_MAP_CMP() [7/7]

typedef OpenDDS::RTPS::Sedp::OPENDDS_MAP_CMP	(	GUID_t	,
		DDS::Security::DatawriterCryptoTokenSeq	,
		GUID_tKeyLessThan
	)

protected

◆ OPENDDS_SET()

OpenDDS::RTPS::Sedp::OPENDDS_SET ( String )

protected

◆ OPENDDS_SET_CMP()

OpenDDS::RTPS::Sedp::OPENDDS_SET_CMP	(	GUID_t	,
		GUID_tKeyLessThan
	)

protected

◆ populate_discovered_reader_msg()

void OpenDDS::RTPS::Sedp::populate_discovered_reader_msg	(	DCPS::DiscoveredReaderData &	drd,
		const DCPS::GUID_t &	subscription_id,
		const LocalSubscription &	sub
	)

private

Definition at line 4586 of file Sedp.cpp.

Referenced by write_subscription_data_secure(), and write_subscription_data_unsecure().

 {
   // Ignored on the wire drd.ddsSubscription.key
   // Ignored on the wire drd.ddsSubscription.participant_key
   OPENDDS_STRING topic_name = topic_names_[sub.topic_id_];
   drd.ddsSubscriptionData.topic_name = topic_name.c_str();
   TopicDetails& topic_details = topics_[topic_name];
   drd.ddsSubscriptionData.type_name = topic_details.local_data_type_name().c_str();
   drd.ddsSubscriptionData.durability = sub.qos_.durability;
   drd.ddsSubscriptionData.deadline = sub.qos_.deadline;
   drd.ddsSubscriptionData.latency_budget = sub.qos_.latency_budget;
   drd.ddsSubscriptionData.liveliness = sub.qos_.liveliness;
   drd.ddsSubscriptionData.reliability = sub.qos_.reliability;
   drd.ddsSubscriptionData.ownership = sub.qos_.ownership;
   drd.ddsSubscriptionData.destination_order = sub.qos_.destination_order;
   drd.ddsSubscriptionData.user_data = sub.qos_.user_data;
   drd.ddsSubscriptionData.time_based_filter = sub.qos_.time_based_filter;
   drd.ddsSubscriptionData.representation  = sub.qos_.representation;
   drd.ddsSubscriptionData.presentation = sub.subscriber_qos_.presentation;
   drd.ddsSubscriptionData.partition = sub.subscriber_qos_.partition;
   drd.ddsSubscriptionData.topic_data = topic_details.local_qos().topic_data;
   drd.ddsSubscriptionData.group_data = sub.subscriber_qos_.group_data;
   drd.ddsSubscriptionData.type_consistency = sub.qos_.type_consistency;
 
   drd.readerProxy.remoteReaderGuid = subscription_id;
   drd.readerProxy.expectsInlineQos = false;  // We never expect inline qos
   // Ignore drd.readerProxy.unicastLocatorList;
   // Ignore drd.readerProxy.multicastLocatorList;
   drd.readerProxy.allLocators = sub.trans_info_;
 
   drd.contentFilterProperty.contentFilteredTopicName =
     DCPS::LogGuid(subscription_id).c_str();
   drd.contentFilterProperty.relatedTopicName = topic_name.c_str();
   drd.contentFilterProperty.filterClassName = ""; // PLConverter adds default
   drd.contentFilterProperty.filterExpression = sub.filterProperties.filterExpression;
   drd.contentFilterProperty.expressionParameters = sub.filterProperties.expressionParameters;
 
   const CORBA::ULong len = drd.readerProxy.associatedWriters.length();
   const CORBA::ULong added_len = static_cast<CORBA::ULong>(sub.remote_expectant_opendds_associations_.size());
   drd.readerProxy.associatedWriters.length(len + added_len);
 
   CORBA::ULong i = 0;
   for (DCPS::RepoIdSet::const_iterator writer =
          sub.remote_expectant_opendds_associations_.begin();
        writer != sub.remote_expectant_opendds_associations_.end();
        ++writer) {
     drd.readerProxy.associatedWriters[len + i] = *writer;
     ++i;
   }
 }

◆ populate_discovered_writer_msg()

void OpenDDS::RTPS::Sedp::populate_discovered_writer_msg	(	DCPS::DiscoveredWriterData &	dwd,
		const DCPS::GUID_t &	publication_id,
		const LocalPublication &	pub
	)

private

Definition at line 4551 of file Sedp.cpp.

Referenced by write_publication_data_secure(), and write_publication_data_unsecure().

 {
   // Ignored on the wire dwd.ddsPublicationData.key
   // Ignored on the wire dwd.ddsPublicationData.participant_key
   OPENDDS_STRING topic_name = topic_names_[pub.topic_id_];
   dwd.ddsPublicationData.topic_name = topic_name.c_str();
   TopicDetails& topic_details = topics_[topic_name];
   dwd.ddsPublicationData.type_name = topic_details.local_data_type_name().c_str();
   dwd.ddsPublicationData.durability = pub.qos_.durability;
   dwd.ddsPublicationData.durability_service = pub.qos_.durability_service;
   dwd.ddsPublicationData.deadline = pub.qos_.deadline;
   dwd.ddsPublicationData.latency_budget = pub.qos_.latency_budget;
   dwd.ddsPublicationData.liveliness = pub.qos_.liveliness;
   dwd.ddsPublicationData.reliability = pub.qos_.reliability;
   dwd.ddsPublicationData.lifespan = pub.qos_.lifespan;
   dwd.ddsPublicationData.user_data = pub.qos_.user_data;
   dwd.ddsPublicationData.ownership = pub.qos_.ownership;
   dwd.ddsPublicationData.ownership_strength = pub.qos_.ownership_strength;
   dwd.ddsPublicationData.destination_order = pub.qos_.destination_order;
   dwd.ddsPublicationData.representation = pub.qos_.representation;
   dwd.ddsPublicationData.presentation = pub.publisher_qos_.presentation;
   dwd.ddsPublicationData.partition = pub.publisher_qos_.partition;
   dwd.ddsPublicationData.topic_data = topic_details.local_qos().topic_data;
   dwd.ddsPublicationData.group_data = pub.publisher_qos_.group_data;
 
   dwd.writerProxy.remoteWriterGuid = publication_id;
   // Ignore dwd.writerProxy.unicastLocatorList;
   // Ignore dwd.writerProxy.multicastLocatorList;
   dwd.writerProxy.allLocators = pub.trans_info_;
 }

◆ populate_origination_locator()

void OpenDDS::RTPS::Sedp::populate_origination_locator	(	const GUID_t &	id,
		DCPS::TransportLocator &	tl
	)

private

Definition at line 7017 of file Sedp.cpp.

References OpenDDS::DCPS::TransportLocator::data, OpenDDS::STUN::encoding(), OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER, OpenDDS::RTPS::Spdp::get_last_recv_locator(), OpenDDS::DCPS::TransportInst::get_last_recv_locator(), OpenDDS::RTPS::get_locators_encoding(), OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity(), OpenDDS::DCPS::GuidConverter::isReader(), OpenDDS::DCPS::make_id(), OpenDDS::RTPS::message_block_to_sequence(), OpenDDS::DCPS::primitive_serialized_size_boolean(), OpenDDS::DCPS::serialized_size(), spdp_, transport_inst_, and OpenDDS::DCPS::TransportLocator::transport_type.

Referenced by match_continue(), and process_association_records_i().

 {
   DCPS::GuidConverter conv(id);
   if (conv.isBuiltinDomainEntity()) {
     DCPS::LocatorSeq locators;
     bool expects_inline_qos = false;
     bool found = spdp_.get_last_recv_locator(make_id(id, ENTITYID_PARTICIPANT), locators, expects_inline_qos);
 
     if (!found || !locators.length()) {
       return;
     }
 
     const Encoding& encoding = RTPS::get_locators_encoding();
     size_t size = serialized_size(encoding, locators);
     primitive_serialized_size_boolean(encoding, size);
 
     ACE_Message_Block mb_locator(size);
     Serializer ser_loc(&mb_locator, encoding);
     ser_loc << locators;
     ser_loc << ACE_OutputCDR::from_boolean(expects_inline_qos);
 
     tl.transport_type = "rtps_udp";
     RTPS::message_block_to_sequence(mb_locator, tl.data);
   } else {
     if (conv.isReader()) {
       transport_inst_->get_last_recv_locator(make_id(id, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER), tl);
     } else {
       transport_inst_->get_last_recv_locator(make_id(id, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER), tl);
     }
   }
 }

◆ populate_transport_locator_sequence() [1/2]

void OpenDDS::RTPS::Sedp::populate_transport_locator_sequence	(	DCPS::TransportLocatorSeq &	tls,
		DiscoveredSubscriptionIter &	iter,
		const DCPS::GUID_t &	reader
	)

privatevirtual

Definition at line 5176 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::TransportLocator::data, OpenDDS::STUN::encoding(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::RTPS::Spdp::get_default_locators(), OpenDDS::RTPS::get_locators_encoding(), LM_WARNING, OpenDDS::RTPS::message_block_to_sequence(), OpenDDS::DCPS::primitive_serialized_size_boolean(), OpenDDS::DCPS::serialized_size(), spdp_, and OpenDDS::DCPS::TransportLocator::transport_type.

Referenced by match_continue().

 {
   DCPS::LocatorSeq locs;
   bool participantExpectsInlineQos = false;
   GUID_t remote_participant = reader;
   remote_participant.entityId = ENTITYID_PARTICIPANT;
   const bool participant_found =
     spdp_.get_default_locators(remote_participant, locs,
                                participantExpectsInlineQos);
   if (!rTls.length()) {     // if no locators provided, add the default
     if (!participant_found) {
       return;
     } else if (locs.length()) {
       const Encoding& encoding = get_locators_encoding();
       size_t size = DCPS::serialized_size(encoding, locs);
       DCPS::primitive_serialized_size_boolean(encoding, size);
 
       ACE_Message_Block mb_locator(size);
       Serializer ser_loc(&mb_locator, encoding);
       ser_loc << locs;
       const bool readerExpectsInlineQos =
         dsi->second.reader_data_.readerProxy.expectsInlineQos;
       ser_loc << ACE_OutputCDR::from_boolean(participantExpectsInlineQos
                                              || readerExpectsInlineQos);
 
       DCPS::TransportLocator tl;
       tl.transport_type = "rtps_udp";
       message_block_to_sequence(mb_locator, tl.data);
       rTls.length(1);
       rTls[0] = tl;
     } else {
       ACE_DEBUG((LM_WARNING,
                  ACE_TEXT("(%P|%t) Sedp::match - ")
                  ACE_TEXT("remote reader found with no locators ")
                  ACE_TEXT("and no default locators\n")));
     }
   }
 }

◆ populate_transport_locator_sequence() [2/2]

void OpenDDS::RTPS::Sedp::populate_transport_locator_sequence	(	DCPS::TransportLocatorSeq &	tls,
		DiscoveredPublicationIter &	iter,
		const DCPS::GUID_t &	writer
	)

privatevirtual

Definition at line 5218 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::TransportLocator::data, OpenDDS::STUN::encoding(), OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::RTPS::Spdp::get_default_locators(), OpenDDS::RTPS::get_locators_encoding(), LM_WARNING, OpenDDS::RTPS::message_block_to_sequence(), OpenDDS::DCPS::primitive_serialized_size_boolean(), OpenDDS::DCPS::serialized_size(), spdp_, and OpenDDS::DCPS::TransportLocator::transport_type.

 {
   DCPS::LocatorSeq locs;
   bool participantExpectsInlineQos = false;
   GUID_t remote_participant = writer;
   remote_participant.entityId = ENTITYID_PARTICIPANT;
   const bool participant_found =
     spdp_.get_default_locators(remote_participant, locs,
                                participantExpectsInlineQos);
   if (!wTls.length()) {     // if no locators provided, add the default
     if (!participant_found) {
       return;
     } else if (locs.length()) {
       const Encoding& encoding = get_locators_encoding();
       size_t size = DCPS::serialized_size(encoding, locs);
       DCPS::primitive_serialized_size_boolean(encoding, size);
 
       ACE_Message_Block mb_locator(size);
       Serializer ser_loc(&mb_locator, encoding);
       ser_loc << locs;
       ser_loc << ACE_OutputCDR::from_boolean(participantExpectsInlineQos);
 
       DCPS::TransportLocator tl;
       tl.transport_type = "rtps_udp";
       message_block_to_sequence(mb_locator, tl.data);
       wTls.length(1);
       wTls[0] = tl;
     } else {
       ACE_DEBUG((LM_WARNING,
                  ACE_TEXT("(%P|%t) Sedp::match - ")
                  ACE_TEXT("remote writer found with no locators ")
                  ACE_TEXT("and no default locators\n")));
     }
   }
 }

◆ process_association_records_i()

void OpenDDS::RTPS::Sedp::process_association_records_i ( DiscoveredParticipant & participant )

Definition at line 1264 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::DiscoveredParticipant::builtin_associated_records_, OpenDDS::RTPS::DiscoveredParticipant::builtin_pending_records_, OpenDDS::RTPS::create_association_data_proto(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::AssociationData::discovery_locator_, OpenDDS::DCPS::EventDispatcher::dispatch(), event_dispatcher_, OpenDDS::DCPS::GuidConverter::isReader(), LM_INFO, OpenDDS::RTPS::BuiltinAssociationRecord::local_id(), OpenDDS::RTPS::BuiltinAssociationRecord::local_tokens_sent(), OpenDDS::RTPS::DiscoveredParticipant::pdata_, populate_origination_locator(), OpenDDS::RTPS::DiscoveredParticipant::reader_associated_records_, OpenDDS::RTPS::WriterAssociationRecord::reader_id(), OpenDDS::RTPS::ReaderAssociationRecord::reader_id(), OpenDDS::RTPS::DiscoveredParticipant::reader_pending_records_, ready(), OpenDDS::RTPS::BuiltinAssociationRecord::remote_durable(), OpenDDS::DCPS::AssociationData::remote_durable_, OpenDDS::RTPS::BuiltinAssociationRecord::remote_id(), OpenDDS::DCPS::AssociationData::remote_id_, OpenDDS::RTPS::BuiltinAssociationRecord::remote_reliable(), OpenDDS::DCPS::AssociationData::remote_reliable_, OpenDDS::RTPS::BuiltinAssociationRecord::transport_client_, OpenDDS::RTPS::DiscoveredParticipant::writer_associated_records_, OpenDDS::RTPS::WriterAssociationRecord::writer_id(), OpenDDS::RTPS::ReaderAssociationRecord::writer_id(), and OpenDDS::RTPS::DiscoveredParticipant::writer_pending_records_.

Referenced by associate(), data_acked_i(), handle_datareader_crypto_tokens(), handle_datawriter_crypto_tokens(), and match_continue().

 {
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = participant.builtin_pending_records_.begin(),
          limit = participant.builtin_pending_records_.end(); pos != limit;) {
     const BuiltinAssociationRecord& record = *pos;
     if (ready(participant, record.local_id(), record.remote_id(), record.local_tokens_sent())) {
       if (DCPS::DCPS_debug_level > 3) {
         ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::process_association_records_i associating built-ins local %C remote %C pending %B done %B\n"),
                    LogGuid(record.local_id()).c_str(), LogGuid(record.remote_id()).c_str(), participant.builtin_pending_records_.size(), participant.builtin_associated_records_.size()));
       }
 
       DCPS::AssociationData association_data;
       create_association_data_proto(association_data, participant.pdata_);
       populate_origination_locator(record.remote_id(), association_data.discovery_locator_);
       association_data.remote_id_ = record.remote_id();
       association_data.remote_reliable_ = record.remote_reliable();
       association_data.remote_durable_ = record.remote_durable();
       record.transport_client_->associate(association_data, DCPS::GuidConverter(association_data.remote_id_).isReader());
 
       participant.builtin_associated_records_.push_back(record);
       participant.builtin_pending_records_.erase(pos++);
 
     } else {
       if (DCPS::DCPS_debug_level > 6) {
         ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::process_association_records_i builtin not ready local %C remote %C pending %B done %B\n"),
                    LogGuid(record.local_id()).c_str(), LogGuid(record.remote_id()).c_str(), participant.builtin_pending_records_.size(), participant.builtin_associated_records_.size()));
       }
 
       ++pos;
     }
   }
 
   for (DiscoveredParticipant::WriterAssociationRecords::iterator pos = participant.writer_pending_records_.begin(),
          limit = participant.writer_pending_records_.end(); pos != limit;) {
     const WriterAssociationRecord& record = **pos;
     // The local tokens have already been sent.
     if (ready(participant, record.writer_id(), record.reader_id(), true)) {
       event_dispatcher_->dispatch(DCPS::make_rch<WriterAddAssociation>(*pos));
 
       participant.writer_associated_records_.push_back(*pos);
       participant.writer_pending_records_.erase(pos++);
     } else {
       if (DCPS::DCPS_debug_level > 6) {
         ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::process_association_records_i writer not ready local %C remote %C pending %B done %B\n"),
                    LogGuid(record.writer_id()).c_str(), LogGuid(record.reader_id()).c_str(), participant.writer_pending_records_.size(), participant.writer_associated_records_.size()));
       }
       ++pos;
     }
   }
 
   for (DiscoveredParticipant::ReaderAssociationRecords::iterator pos = participant.reader_pending_records_.begin(),
          limit = participant.reader_pending_records_.end(); pos != limit;) {
     const ReaderAssociationRecord& record = **pos;
     // The local tokens have already been sent.
     if (ready(participant, record.reader_id(), record.writer_id(), true)) {
       event_dispatcher_->dispatch(DCPS::make_rch<ReaderAddAssociation>(*pos));
 
       participant.reader_associated_records_.push_back(*pos);
       participant.reader_pending_records_.erase(pos++);
     } else {
       if (DCPS::DCPS_debug_level > 6) {
         ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::process_association_records_i reader not ready local %C remote %C pending %B done %B\n"),
                    LogGuid(record.reader_id()).c_str(), LogGuid(record.writer_id()).c_str(), participant.reader_pending_records_.size(), participant.reader_associated_records_.size()));
       }
       ++pos;
     }
   }
 }

◆ process_discovered_reader_data()

void OpenDDS::RTPS::Sedp::process_discovered_reader_data	(	DCPS::MessageId	message_id,
		const DCPS::DiscoveredReaderData &	rdata,
		const DCPS::GUID_t &	guid,
		const XTypes::TypeInformation &	type_info,
		bool	have_ice_agent_info,
		const ICE::AgentInfo &	ice_agent_info,
		const DDS::Security::EndpointSecurityInfo *	security_info = `NULL`
	)

private

Definition at line 2336 of file Sedp.cpp.

Referenced by data_received().

 {
   OPENDDS_STRING topic_name;
 
   GUID_t participant_id = guid;
   participant_id.entityId = ENTITYID_PARTICIPANT;
 
   // Find the subscripion - iterator valid only as long as we hold the lock
   DiscoveredSubscriptionIter iter = discovered_subscriptions_.find(guid);
 
   if (message_id == DCPS::SAMPLE_DATA) {
     DCPS::DiscoveredReaderData rdata_copy;
 
 #ifdef OPENDDS_SECURITY
     if (iter != discovered_subscriptions_.end()) {
       DiscoveredSubscription& dsub = iter->second;
       if (!dsub.have_ice_agent_info_ && have_ice_agent_info) {
         dsub.have_ice_agent_info_ = have_ice_agent_info;
         dsub.ice_agent_info_ = ice_agent_info;
         start_ice(guid, dsub);
       } else if (dsub.have_ice_agent_info_ && !have_ice_agent_info) {
         dsub.have_ice_agent_info_ = have_ice_agent_info;
         dsub.ice_agent_info_ = ice_agent_info;
         stop_ice(guid, dsub);
       } else if (dsub.ice_agent_info_ != ice_agent_info) {
         dsub.ice_agent_info_ = ice_agent_info;
         start_ice(guid, dsub);
       }
     }
 #endif
 
     if (iter == discovered_subscriptions_.end()) { // add new
       DiscoveredSubscription presub(rdata);
       presub.participant_discovered_at_ = spdp_.get_participant_discovered_at(participant_id);
       presub.transport_context_ = spdp_.get_participant_flags(participant_id);
       presub.type_info_ = type_info;
 #ifdef OPENDDS_SECURITY
       presub.have_ice_agent_info_ = have_ice_agent_info;
       presub.ice_agent_info_ = ice_agent_info;
 #endif
 
       topic_name = presub.get_topic_name();
 
 #ifdef OPENDDS_SECURITY
       if (is_security_enabled()) {
 
         DDS::Security::SecurityException ex = {"", 0, 0};
 
         DDS::TopicBuiltinTopicData data;
         data.key = rdata.ddsSubscriptionData.key;
         data.name = rdata.ddsSubscriptionData.topic_name;
         data.type_name = rdata.ddsSubscriptionData.type_name;
         data.durability = rdata.ddsSubscriptionData.durability;
         data.deadline = rdata.ddsSubscriptionData.deadline;
         data.latency_budget = rdata.ddsSubscriptionData.latency_budget;
         data.liveliness = rdata.ddsSubscriptionData.liveliness;
         data.reliability = rdata.ddsSubscriptionData.reliability;
         data.destination_order = rdata.ddsSubscriptionData.destination_order;
         data.ownership = rdata.ddsSubscriptionData.ownership;
         data.topic_data = rdata.ddsSubscriptionData.topic_data;
 
         AuthState auth_state = spdp_.lookup_participant_auth_state(participant_id);
         if (auth_state == AUTH_STATE_AUTHENTICATED) {
 
           DDS::Security::PermissionsHandle remote_permissions = spdp_.lookup_participant_permissions(participant_id);
 
           if (participant_sec_attr_.is_access_protected &&
               !get_access_control()->check_remote_topic(remote_permissions, spdp_.get_domain_id(), data, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_reader_data - ")
                          ACE_TEXT("Unable to check remote topic '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
 
           DDS::Security::TopicSecurityAttributes topic_sec_attr;
           if (!get_access_control()->get_topic_sec_attributes(remote_permissions, topic_name.data(), topic_sec_attr, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_reader_data - ")
                          ACE_TEXT("Unable to get security attributes for remote topic '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
 
           DDS::Security::SubscriptionBuiltinTopicDataSecure sub_data_sec;
           sub_data_sec.base.base = rdata.ddsSubscriptionData;
 
           if (security_info != NULL) {
             sub_data_sec.base.security_info.endpoint_security_attributes =
               security_info->endpoint_security_attributes;
             sub_data_sec.base.security_info.plugin_endpoint_security_attributes =
               security_info->plugin_endpoint_security_attributes;
           }
 
           bool relay_only = false;
           if (topic_sec_attr.is_read_protected &&
               !get_access_control()->check_remote_datareader(
                                                              remote_permissions, spdp_.get_domain_id(), sub_data_sec, relay_only, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_reader_data - ")
                          ACE_TEXT("Unable to check remote datareader '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
 
           if (relay_only) {
             relay_only_readers_.insert(guid);
           } else {
             relay_only_readers_.erase(guid);
           }
         } else if (auth_state != AUTH_STATE_UNAUTHENTICATED) {
           ACE_ERROR((LM_WARNING,
                      ACE_TEXT("(%P|%t) WARNING: ")
                      ACE_TEXT("Sedp::process_discovered_reader_data - ")
                      ACE_TEXT("Unsupported remote participant authentication state for discovered datareader '%C'. ")
                      ACE_TEXT("SecurityException[%d.%d]: %C\n"),
                      topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
           return;
         }
       }
 #endif
 
       DiscoveredSubscription& sub = discovered_subscriptions_[guid] = presub;
 
       // Create a topic if necessary.
       TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it == topics_.end()) {
         top_it = topics_.insert(std::make_pair(topic_name, TopicDetails())).first;
         DCPS::GUID_t topic_id = make_topic_guid();
         top_it->second.init(topic_name, topic_id);
         topic_names_[topic_id] = topic_name;
       }
 
       TopicDetails& td = top_it->second;
 
       // Upsert the remote topic.
       td.add_discovered_subscription(guid);
 
       assign_bit_key(sub);
       rdata_copy = sub.reader_data_;
 
       sub.bit_ih_ = spdp_.bit_subscriber_->add_subscription(rdata_copy.ddsSubscriptionData, DDS::NEW_VIEW_STATE);
       if (spdp_.shutting_down()) { return; }
 
       if (DCPS::DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_reader_data - ")
                    ACE_TEXT("calling match_endpoints new\n")));
       }
       if (DCPS::transport_debug.log_progress) {
         DCPS::log_progress("discovered reader data new", participant_id_, participant_id, spdp_.get_participant_discovered_at(participant_id), guid);
       }
       match_endpoints(guid, top_it->second);
     } else { // update existing
       if (checkAndAssignQos(iter->second.reader_data_.ddsSubscriptionData,
                             rdata.ddsSubscriptionData)) {
 
         spdp_.bit_subscriber_->add_subscription(iter->second.reader_data_.ddsSubscriptionData, DDS::NOT_NEW_VIEW_STATE);
         if (spdp_.shutting_down()) { return; }
 
         // Match/unmatch local publication(s)
         topic_name = iter->second.get_topic_name();
         TopicDetailsMap::iterator top_it = topics_.find(topic_name);
         if (top_it != topics_.end()) {
           if (DCPS::DCPS_debug_level > 3) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_reader_data - ")
                        ACE_TEXT("calling match_endpoints update\n")));
           }
           if (DCPS::transport_debug.log_progress) {
             log_progress("discovered reader data update", participant_id_, participant_id,
                          spdp_.get_participant_discovered_at(participant_id), guid);
           }
           match_endpoints(guid, top_it->second);
           iter = discovered_subscriptions_.find(guid);
           if (iter == discovered_subscriptions_.end()) {
             return;
           }
         }
       }
 
       if (checkAndAssignParams(iter->second.reader_data_.contentFilterProperty,
                                rdata.contentFilterProperty)) {
         // Let any associated local publications know about the change
         topic_name = iter->second.get_topic_name();
         TopicDetailsMap::iterator top_it = topics_.find(topic_name);
         using DCPS::RepoIdSet;
         const RepoIdSet& assoc =
           (top_it == topics_.end()) ? RepoIdSet() : top_it->second.local_publications();
         for (RepoIdSet::const_iterator i = assoc.begin(); i != assoc.end(); ++i) {
           const LocalPublicationIter lpi = local_publications_.find(*i);
           if (lpi != local_publications_.end()) {
             DCPS::DataWriterCallbacks_rch pl = lpi->second.publication_.lock();
             if (pl) {
               pl->update_subscription_params(guid, rdata.contentFilterProperty.expressionParameters);
             }
           }
         }
       }
 
       if (checkAndAssignLocators(iter->second.reader_data_.readerProxy, rdata.readerProxy)) {
         topic_name = iter->second.get_topic_name();
         TopicDetailsMap::const_iterator top_it = topics_.find(topic_name);
         using DCPS::RepoIdSet;
         const RepoIdSet& assoc =
           (top_it == topics_.end()) ? RepoIdSet() : top_it->second.local_publications();
         for (RepoIdSet::const_iterator i = assoc.begin(); i != assoc.end(); ++i) {
           LocalPublicationIter lpi = local_publications_.find(*i);
           OPENDDS_ASSERT(lpi != local_publications_.end());
           if (lpi != local_publications_.end()) {
             DCPS::DataWriterCallbacks_rch pl = lpi->second.publication_.lock();
             if (pl) {
               pl->update_locators(guid, rdata.readerProxy.allLocators);
             }
           }
         }
       }
     }
 
     if (is_expectant_opendds(guid)) {
       // For each associated opendds writer to this reader
       CORBA::ULong len = rdata.readerProxy.associatedWriters.length();
       for (CORBA::ULong writerIndex = 0; writerIndex < len; ++writerIndex) {
         GUID_t writerGuid = rdata.readerProxy.associatedWriters[writerIndex];
 
         // If the associated writer is in this participant
         LocalPublicationIter lp = local_publications_.find(writerGuid);
         if (lp != local_publications_.end()) {
           // If the local writer is not fully associated with the reader
           lp->second.remote_expectant_opendds_associations_.insert(guid);
         }
       }
     }
 
   } else if (message_id == DCPS::UNREGISTER_INSTANCE ||
              message_id == DCPS::DISPOSE_INSTANCE ||
              message_id == DCPS::DISPOSE_UNREGISTER_INSTANCE) {
     if (iter != discovered_subscriptions_.end()) {
       // Unmatch local publication(s)
       topic_name = iter->second.get_topic_name();
       TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it != topics_.end()) {
         top_it->second.remove_discovered_subscription(guid);
         if (DCPS::DCPS_debug_level > 3) {
           ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_reader_data - ")
                      ACE_TEXT("calling match_endpoints disp/unreg\n")));
         }
         if (DCPS::transport_debug.log_progress) {
           log_progress("discovered reader data disposed", participant_id_, participant_id,
                        spdp_.get_participant_discovered_at(participant_id), guid);
         }
         match_endpoints(guid, top_it->second, true /*remove*/);
         if (top_it->second.is_dead()) {
           purge_dead_topic(topic_name);
         }
         if (spdp_.shutting_down()) { return; }
       }
       DiscoveredSubscription s = iter->second;
       discovered_subscriptions_.erase(iter);
       remove_from_bit(s);
     }
   }
 }

◆ process_discovered_writer_data()

void OpenDDS::RTPS::Sedp::process_discovered_writer_data	(	DCPS::MessageId	message_id,
		const DCPS::DiscoveredWriterData &	wdata,
		const DCPS::GUID_t &	guid,
		const XTypes::TypeInformation &	type_info,
		bool	have_ice_agent_info,
		const ICE::AgentInfo &	ice_agent_info,
		const DDS::Security::EndpointSecurityInfo *	security_info = `NULL`
	)

private

Definition at line 2042 of file Sedp.cpp.

Referenced by data_received().

 {
   OPENDDS_STRING topic_name;
 
   const GUID_t participant_id = make_part_guid(guid);
 
   // Find the publication - iterator valid only as long as we hold the lock
   DiscoveredPublicationIter iter = discovered_publications_.find(guid);
 
   if (message_id == DCPS::SAMPLE_DATA) {
     DCPS::DiscoveredWriterData wdata_copy;
 
 #ifdef OPENDDS_SECURITY
     if (iter != discovered_publications_.end()) {
       DiscoveredPublication& dpub = iter->second;
       if (!dpub.have_ice_agent_info_ && have_ice_agent_info) {
         dpub.have_ice_agent_info_ = have_ice_agent_info;
         dpub.ice_agent_info_ = ice_agent_info;
         start_ice(guid, dpub);
       } else if (dpub.have_ice_agent_info_ && !have_ice_agent_info) {
         dpub.have_ice_agent_info_ = have_ice_agent_info;
         dpub.ice_agent_info_ = ice_agent_info;
         stop_ice(guid, dpub);
       } else if (dpub.ice_agent_info_ != ice_agent_info) {
         dpub.ice_agent_info_ = ice_agent_info;
         start_ice(guid, dpub);
       }
     }
 #endif
 
     if (iter == discovered_publications_.end()) { // add new
       DiscoveredPublication prepub(wdata);
       prepub.participant_discovered_at_ = spdp_.get_participant_discovered_at(participant_id);
       prepub.transport_context_ = spdp_.get_participant_flags(participant_id);
       prepub.type_info_ = type_info;
 
 #ifdef OPENDDS_SECURITY
       prepub.have_ice_agent_info_ = have_ice_agent_info;
       prepub.ice_agent_info_ = ice_agent_info;
 #endif
       topic_name = prepub.get_topic_name();
 
 #ifdef OPENDDS_SECURITY
       if (is_security_enabled()) {
 
         DDS::Security::SecurityException ex = {"", 0, 0};
 
         DDS::TopicBuiltinTopicData data;
         data.key = wdata.ddsPublicationData.key;
         data.name = wdata.ddsPublicationData.topic_name;
         data.type_name = wdata.ddsPublicationData.type_name;
         data.durability = wdata.ddsPublicationData.durability;
         data.durability_service = wdata.ddsPublicationData.durability_service;
         data.deadline = wdata.ddsPublicationData.deadline;
         data.latency_budget = wdata.ddsPublicationData.latency_budget;
         data.liveliness = wdata.ddsPublicationData.liveliness;
         data.reliability = wdata.ddsPublicationData.reliability;
         data.lifespan = wdata.ddsPublicationData.lifespan;
         data.destination_order = wdata.ddsPublicationData.destination_order;
         data.ownership = wdata.ddsPublicationData.ownership;
         data.topic_data = wdata.ddsPublicationData.topic_data;
 
         AuthState auth_state = spdp_.lookup_participant_auth_state(participant_id);
         if (auth_state == AUTH_STATE_AUTHENTICATED) {
 
           DDS::Security::PermissionsHandle remote_permissions = spdp_.lookup_participant_permissions(participant_id);
 
           if (participant_sec_attr_.is_access_protected &&
               !get_access_control()->check_remote_topic(remote_permissions, spdp_.get_domain_id(), data, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_writer_data - ")
                          ACE_TEXT("Unable to check remote topic '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
 
           DDS::Security::TopicSecurityAttributes topic_sec_attr;
           if (!get_access_control()->get_topic_sec_attributes(remote_permissions, topic_name.data(), topic_sec_attr, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_writer_data - ")
                          ACE_TEXT("Unable to get security attributes for remote topic '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
 
           DDS::Security::PublicationBuiltinTopicDataSecure pub_data_sec;
           pub_data_sec.base.base = wdata.ddsPublicationData;
 
           if (security_info != NULL) {
             pub_data_sec.base.security_info.endpoint_security_attributes =
               security_info->endpoint_security_attributes;
             pub_data_sec.base.security_info.plugin_endpoint_security_attributes =
               security_info->plugin_endpoint_security_attributes;
           }
 
           if (topic_sec_attr.is_write_protected &&
               !get_access_control()->check_remote_datawriter(remote_permissions, spdp_.get_domain_id(), pub_data_sec, ex))
             {
               ACE_ERROR((LM_WARNING,
                          ACE_TEXT("(%P|%t) WARNING: ")
                          ACE_TEXT("Sedp::process_discovered_writer_data - ")
                          ACE_TEXT("Unable to check remote datawriter '%C'. SecurityException[%d.%d]: %C\n"),
                          topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
               return;
             }
         } else if (auth_state != AUTH_STATE_UNAUTHENTICATED) {
           ACE_ERROR((LM_WARNING,
                      ACE_TEXT("(%P|%t) WARNING: ")
                      ACE_TEXT("Sedp::process_discovered_writer_data - ")
                      ACE_TEXT("Unsupported remote participant authentication state for discovered datawriter '%C'. ")
                      ACE_TEXT("SecurityException[%d.%d]: %C\n"),
                      topic_name.data(), ex.code, ex.minor_code, ex.message.in()));
           return;
         }
       }
 #endif
 
       DiscoveredPublication& pub = discovered_publications_[guid] = prepub;
 
       // Create a topic if necessary.
       TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it == topics_.end()) {
         top_it = topics_.insert(std::make_pair(topic_name, TopicDetails())).first;
         DCPS::GUID_t topic_id = make_topic_guid();
         top_it->second.init(topic_name, topic_id);
         topic_names_[topic_id] = topic_name;
       }
 
       TopicDetails& td = top_it->second;
 
       // Upsert the remote topic.
       td.add_discovered_publication(guid);
 
       assign_bit_key(pub);
       wdata_copy = pub.writer_data_;
 
       pub.bit_ih_ = spdp_.bit_subscriber_->add_publication(wdata_copy.ddsPublicationData, DDS::NEW_VIEW_STATE);
       if (spdp_.shutting_down()) { return; }
 
       if (DCPS::DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_writer_data - ")
                    ACE_TEXT("calling match_endpoints new\n")));
       }
       if (DCPS::transport_debug.log_progress) {
         DCPS::log_progress("discovered writer data new", participant_id_, participant_id, spdp_.get_participant_discovered_at(participant_id), guid);
       }
       match_endpoints(guid, top_it->second);
     } else {
       if (checkAndAssignQos(iter->second.writer_data_.ddsPublicationData,
                             wdata.ddsPublicationData)) { // update existing
 
         spdp_.bit_subscriber_->add_publication(iter->second.writer_data_.ddsPublicationData, DDS::NOT_NEW_VIEW_STATE);
         if (spdp_.shutting_down()) { return; }
 
         // Match/unmatch local subscription(s)
         topic_name = iter->second.get_topic_name();
         TopicDetailsMap::iterator top_it = topics_.find(topic_name);
         if (top_it != topics_.end()) {
           if (DCPS::DCPS_debug_level > 3) {
             ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_writer_data - ")
                        ACE_TEXT("calling match_endpoints update\n")));
           }
           if (DCPS::transport_debug.log_progress) {
             log_progress("discovered writer data update", participant_id_, participant_id,
                          spdp_.get_participant_discovered_at(participant_id), guid);
           }
           match_endpoints(guid, top_it->second);
           iter = discovered_publications_.find(guid);
           if (iter == discovered_publications_.end()) {
             return;
           }
         }
       }
 
       if (checkAndAssignLocators(iter->second.writer_data_.writerProxy, wdata.writerProxy)) {
         topic_name = iter->second.get_topic_name();
         TopicDetailsMap::const_iterator top_it = topics_.find(topic_name);
         using DCPS::RepoIdSet;
         const RepoIdSet& assoc =
           (top_it == topics_.end()) ? RepoIdSet() : top_it->second.local_subscriptions();
         for (RepoIdSet::const_iterator i = assoc.begin(); i != assoc.end(); ++i) {
           LocalSubscriptionIter lsi = local_subscriptions_.find(*i);
           if (lsi != local_subscriptions_.end()) {
             DCPS::DataReaderCallbacks_rch sl = lsi->second.subscription_.lock();
             if (sl) {
               sl->update_locators(guid, wdata.writerProxy.allLocators);
             }
           }
         }
       }
     }
 
   } else if (message_id == DCPS::UNREGISTER_INSTANCE ||
              message_id == DCPS::DISPOSE_INSTANCE ||
              message_id == DCPS::DISPOSE_UNREGISTER_INSTANCE) {
     if (iter != discovered_publications_.end()) {
       // Unmatch local subscription(s)
       topic_name = iter->second.get_topic_name();
       TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it != topics_.end()) {
         top_it->second.remove_discovered_publication(guid);
         match_endpoints(guid, top_it->second, true /*remove*/);
         if (spdp_.shutting_down()) { return; }
         if (top_it->second.is_dead()) {
           purge_dead_topic(topic_name);
         }
       }
       DiscoveredPublication p = iter->second;
       discovered_publications_.erase(iter);
       remove_from_bit(p);
       if (DCPS::DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) Sedp::process_discovered_writer_data - ")
                    ACE_TEXT("calling match_endpoints disp/unreg\n")));
       }
       if (DCPS::transport_debug.log_progress) {
         log_progress("discovered writer data disposed", participant_id_, participant_id,
                      spdp_.get_participant_discovered_at(participant_id), guid);
       }
     }
   }
 }

◆ purge_dead_topic()

void OpenDDS::RTPS::Sedp::purge_dead_topic ( const String & topic_name )

inlineprivate

Definition at line 307 of file Sedp.h.

References cleanup_secure_reader(), cleanup_secure_writer(), OPENDDS_MAP_CMP(), topic_names_, and topics_.

Referenced by ignore(), process_discovered_reader_data(), process_discovered_writer_data(), remove_entities_belonging_to(), and remove_topic().

   {
     DCPS::TopicDetailsMap::iterator top_it = topics_.find(topic_name);
     topic_names_.erase(top_it->second.topic_id());
     topics_.erase(top_it);
   }

◆ reactor_task()

DCPS::ReactorTask_rch OpenDDS::RTPS::Sedp::reactor_task ( ) const

inline

Definition at line 197 of file Sedp.h.

References reactor_task_.

197 { return reactor_task_; }

OpenDDS::RTPS::Sedp::reactor_task_

DCPS::ReactorTask_rch reactor_task_

Definition: Sedp.h:772

◆ ready()

bool OpenDDS::RTPS::Sedp::ready	(	const DiscoveredParticipant &	participant,
		const GUID_t &	local_id,
		const GUID_t &	remote_id,
		bool	local_tokens_sent
	)		const

Definition at line 1022 of file Sedp.cpp.

References local_has_remote_endpoint_token_i(), local_has_remote_participant_token_i(), remote_has_local_endpoint_token_i(), remote_has_local_participant_token_i(), remote_is_authenticated_i(), and remote_knows_about_local_i().

Referenced by process_association_records_i().

 {
 #ifndef OPENDDS_SECURITY
   ACE_UNUSED_ARG(participant);
   ACE_UNUSED_ARG(local_tokens_sent);
 #endif
 
   return remote_knows_about_local_i(local_id, remote_id)
 #ifdef OPENDDS_SECURITY
     && remote_is_authenticated_i(local_id, remote_id, participant)
     && local_has_remote_participant_token_i(local_id, remote_id)
     && remote_has_local_participant_token_i(local_id, remote_id, participant)
     && local_has_remote_endpoint_token_i(local_id, remote_id)
     && remote_has_local_endpoint_token_i(local_id, local_tokens_sent, remote_id)
 #endif
     ;
 }

◆ received_participant_message_data_secure()

void OpenDDS::RTPS::Sedp::received_participant_message_data_secure	(	DCPS::MessageId	message_id,
		const ParticipantMessageData &	data
	)

private

Definition at line 2729 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::RTPS::Spdp::has_discovered_participant(), ignoring(), lock_, OpenDDS::DCPS::make_part_guid(), notify_liveliness(), OpenDDS::RTPS::ParticipantMessageData::participantGuid, OpenDDS::RTPS::Spdp::shutting_down(), and spdp_.

Referenced by OpenDDS::RTPS::Sedp::LivelinessReader::data_received_i().

 {
   if (spdp_.shutting_down()) {
     return;
   }
 
   const GUID_t& guid = data.participantGuid;
   const GUID_t guid_participant = make_part_guid(guid);
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   if (ignoring(guid) || ignoring(guid_participant)) {
     return;
   }
 
   if (!spdp_.has_discovered_participant(guid_participant)) {
     return;
   }
 
   notify_liveliness(data);
 }

◆ received_stateless_message()

void OpenDDS::RTPS::Sedp::received_stateless_message	(	DCPS::MessageId	message_id,
		const DDS::Security::ParticipantStatelessMessage &	data
	)

private

Definition at line 2846 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE, DDS::Security::GMCLASSID_SECURITY_AUTH_REQUEST, OpenDDS::RTPS::Spdp::handle_auth_request(), OpenDDS::RTPS::Spdp::handle_handshake_message(), LM_DEBUG, DDS::Security::ParticipantGenericMessage::message_class_id, OpenDDS::DCPS::security_debug, should_drop_stateless_message(), OpenDDS::RTPS::Spdp::shutting_down(), and spdp_.

Referenced by OpenDDS::RTPS::Sedp::SecurityReader::data_received_i().

 {
   if (spdp_.shutting_down()) {
     return;
   }
 
   if (should_drop_stateless_message(msg)) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Sedp::received_stateless_message() - ")
                  ACE_TEXT("dropping\n")));
     }
     return;
   }
 
   if (0 == std::strcmp(msg.message_class_id,
                        DDS::Security::GMCLASSID_SECURITY_AUTH_REQUEST)) {
     spdp_.handle_auth_request(msg);
   } else if (0 == std::strcmp(msg.message_class_id,
                               DDS::Security::GMCLASSID_SECURITY_AUTH_HANDSHAKE)) {
     spdp_.handle_handshake_message(msg);
   } else {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Sedp::received_stateless_message() - ")
                  ACE_TEXT("Unknown message class id\n")));
     }
   }
 }

◆ received_volatile_message_secure()

void OpenDDS::RTPS::Sedp::received_volatile_message_secure	(	DCPS::MessageId	message_id,
		const DDS::Security::ParticipantVolatileMessageSecure &	data
	)

private

Definition at line 2876 of file Sedp.cpp.

References ACE_DEBUG, DDS::Security::GMCLASSID_SECURITY_DATAREADER_CRYPTO_TOKENS, DDS::Security::GMCLASSID_SECURITY_DATAWRITER_CRYPTO_TOKENS, DDS::Security::GMCLASSID_SECURITY_PARTICIPANT_CRYPTO_TOKENS, handle_datareader_crypto_tokens(), handle_datawriter_crypto_tokens(), OpenDDS::RTPS::Spdp::handle_participant_crypto_tokens(), LM_DEBUG, DDS::Security::ParticipantGenericMessage::message_class_id, should_drop_volatile_message(), OpenDDS::RTPS::Spdp::shutting_down(), and spdp_.

Referenced by OpenDDS::RTPS::Sedp::SecurityReader::data_received_i().

 {
   if (spdp_.shutting_down()) {
     return;
   }
 
   if (should_drop_volatile_message(msg)) {
     return;
   }
 
   if (0 == std::strcmp(msg.message_class_id,
                        DDS::Security::GMCLASSID_SECURITY_PARTICIPANT_CRYPTO_TOKENS)) {
     if (!spdp_.handle_participant_crypto_tokens(msg)) {
       ACE_DEBUG((LM_DEBUG, "Sedp::received_volatile_message_secure handle_participant_crypto_tokens failed\n"));
       return;
     }
   } else if (0 == std::strcmp(msg.message_class_id,
                               DDS::Security::GMCLASSID_SECURITY_DATAWRITER_CRYPTO_TOKENS)) {
     if (!handle_datawriter_crypto_tokens(msg)) {
       ACE_DEBUG((LM_DEBUG, "Sedp::received_volatile_message_secure handle_datawriter_crypto_tokens failed\n"));
       return;
     }
   } else if (0 == std::strcmp(msg.message_class_id,
                               DDS::Security::GMCLASSID_SECURITY_DATAREADER_CRYPTO_TOKENS)) {
     if (!handle_datareader_crypto_tokens(msg)) {
       ACE_DEBUG((LM_DEBUG, "Sedp::received_volatile_message_secure handle_datareader_crypto_tokens failed\n"));
       return;
     }
   } else {
     return;
   }
 }

◆ remote_has_local_endpoint_token_i()

bool OpenDDS::RTPS::Sedp::remote_has_local_endpoint_token_i	(	const GUID_t &	local,
		bool	local_tokens_sent,
		const GUID_t &	remote
	)		const

private

Definition at line 6581 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::crypto_handle_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), DDS::HANDLE_NIL, LM_INFO, OpenDDS::DCPS::make_id(), participant_volatile_message_secure_writer_, OpenDDS::RTPS::Spdp::security_config_, and spdp_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::remote_has_local_endpoint_token_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   if (spdp_.crypto_handle_ == DDS::HANDLE_NIL) {
     return true;
   }
 
   if (is_stateless_or_volatile(local)) {
     // Don't need the token so okay.
     return true;
   }
 
   Security::CryptoKeyExchange_var key_exchange = spdp_.security_config_->get_crypto_key_exchange();
   if (DCPS::GuidConverter(local).isWriter()) {
     const DDS::Security::DatawriterCryptoHandle local_crypto_handle =
       get_handle_registry()->get_local_datawriter_crypto_handle(local);
     const DDS::Security::DatareaderCryptoHandle remote_crypto_handle =
       get_handle_registry()->get_remote_datareader_crypto_handle(remote);
     return !key_exchange->have_local_datawriter_crypto_tokens(local_crypto_handle, remote_crypto_handle) ||
       (local_tokens_sent && participant_volatile_message_secure_writer_->is_leading(make_id(remote, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER)));
   } else {
     const DDS::Security::DatareaderCryptoHandle local_crypto_handle =
       get_handle_registry()->get_local_datareader_crypto_handle(local);
     const DDS::Security::DatawriterCryptoHandle remote_crypto_handle =
       get_handle_registry()->get_remote_datawriter_crypto_handle(remote);
     return !key_exchange->have_local_datareader_crypto_tokens(local_crypto_handle, remote_crypto_handle) ||
       (local_tokens_sent && participant_volatile_message_secure_writer_->is_leading(make_id(remote, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER)));
   }
 }

◆ remote_has_local_participant_token_i()

bool OpenDDS::RTPS::Sedp::remote_has_local_participant_token_i	(	const GUID_t &	local,
		const GUID_t &	remote,
		const DiscoveredParticipant &	participant
	)		const

private

Definition at line 6508 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::crypto_handle_, crypto_handle_, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER, OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::Security::SecurityConfig::get_crypto_key_exchange(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_remote_participant_crypto_handle(), DDS::HANDLE_NIL, LM_INFO, OpenDDS::DCPS::make_id(), OpenDDS::RTPS::DiscoveredParticipant::participant_tokens_sent_, participant_volatile_message_secure_writer_, OpenDDS::RTPS::Spdp::security_config_, and spdp_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::remote_has_local_participant_token_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   if (spdp_.crypto_handle_ == DDS::HANDLE_NIL) {
     return true;
   }
 
   const GUID_t remote_part = make_id(remote, ENTITYID_PARTICIPANT);
 
   if (is_stateless_or_volatile(local)) {
     // Don't need the token so okay.
     return true;
   }
 
   Security::CryptoKeyExchange_var key_exchange = spdp_.security_config_->get_crypto_key_exchange();
   const DDS::Security::ParticipantCryptoHandle dp_crypto_handle =
     get_handle_registry()->get_remote_participant_crypto_handle(remote_part);
 
   return !key_exchange->have_local_participant_crypto_tokens(crypto_handle_, dp_crypto_handle) ||
     (participant.participant_tokens_sent_ &&
      participant_volatile_message_secure_writer_->is_leading(make_id(remote, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER)));
 }

◆ remote_is_authenticated_i()

bool OpenDDS::RTPS::Sedp::remote_is_authenticated_i	(	const GUID_t &	local,
		const GUID_t &	remote,
		const DiscoveredParticipant &	participant
	)		const

private

Definition at line 6455 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::ParticipantSecurityAttributes::allow_unauthenticated_participants, OpenDDS::RTPS::DiscoveredParticipant::auth_state_, OpenDDS::RTPS::AUTH_STATE_AUTHENTICATED, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::DiscoveredParticipant::has_security_data(), OpenDDS::RTPS::Spdp::is_security_enabled(), LM_INFO, participant_sec_attr_, and spdp_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::remote_is_authenticated_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   if (!spdp_.is_security_enabled()) {
     return true;
   }
 
   if (is_stateless(local)) {
     // Don't need authentication.
     return true;
   }
 
   if (!participant.has_security_data()) {
     return participant_sec_attr_.allow_unauthenticated_participants;
   } else {
     return participant.auth_state_ == AUTH_STATE_AUTHENTICATED;
   }
 }

◆ remote_knows_about_local_i()

bool OpenDDS::RTPS::Sedp::remote_knows_about_local_i	(	const GUID_t &	local,
		const GUID_t &	remote
	)		const

private

Definition at line 6408 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER, OpenDDS::DCPS::GuidConverter::isBuiltinDomainEntity(), OpenDDS::DCPS::GuidConverter::isWriter(), LM_ERROR, LM_INFO, local_publications_, local_subscriptions_, OpenDDS::DCPS::make_id(), OPENDDS_ASSERT, publications_secure_writer_, publications_writer_, subscriptions_secure_writer_, and subscriptions_writer_.

Referenced by ready().

 {
   if (DCPS_debug_level > 6) {
     ACE_DEBUG((LM_INFO,
                ACE_TEXT("(%P|%t) Sedp::remote_knows_about_local_i: local %C remote %C\n"),
                LogGuid(local).c_str(), LogGuid(remote).c_str()));
   }
 
   const DCPS::GuidConverter gc(local);
   if (gc.isBuiltinDomainEntity()) {
     OPENDDS_ASSERT(DCPS::GuidConverter(remote).isBuiltinDomainEntity());
     // One improvement to returning true here would be waiting until
     // the remote actually sends confirmation that it knows about the
     // local.  A directed SPDP message from the remote would work.
     return true;
   }
 
   if (gc.isWriter()) {
     LocalPublicationCIter pub = local_publications_.find(local);
     if (pub != local_publications_.end()) {
 #ifdef OPENDDS_SECURITY
       if (pub->second.security_attribs_.base.is_discovery_protected) {
         return publications_secure_writer_->is_leading(make_id(remote, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER));
       }
 #endif
       return publications_writer_->is_leading(make_id(remote, ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER));
     } else {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Sedp::remote_knows_about_local_i - could not find local publication %C\n"), LogGuid(local).c_str()));
       return false;
     }
   } else {
     LocalSubscriptionCIter pub = local_subscriptions_.find(local);
     if (pub != local_subscriptions_.end()) {
 #ifdef OPENDDS_SECURITY
       if (pub->second.security_attribs_.base.is_discovery_protected) {
         return subscriptions_secure_writer_->is_leading(make_id(remote, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER));
       }
 #endif
       return subscriptions_writer_->is_leading(make_id(remote, ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER));
     } else {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) Sedp::remote_knows_about_local_i - could not find local subscription %C\n"), LogGuid(local).c_str()));
       return false;
     }
   }
 }

◆ remove_assoc()

void OpenDDS::RTPS::Sedp::remove_assoc	(	const GUID_t &	remove_from,
		const GUID_t &	removing
	)

protected

Definition at line 6790 of file Sedp.cpp.

References cleanup_reader_association(), cleanup_writer_association(), discovered_publications_, discovered_subscriptions_, local_publications_, local_subscriptions_, remove_assoc_i(), and write_subscription_data().

Referenced by assign_topic_key(), and match_endpoints().

 {
   if (DCPS::GuidConverter(remove_from).isReader()) {
     const LocalSubscriptionIter lsi = local_subscriptions_.find(remove_from);
     if (lsi != local_subscriptions_.end()) {
       lsi->second.matched_endpoints_.erase(removing);
       const DiscoveredPublicationIter dpi = discovered_publications_.find(removing);
       if (dpi != discovered_publications_.end()) {
         dpi->second.matched_endpoints_.erase(remove_from);
       }
       const size_t count = lsi->second.remote_expectant_opendds_associations_.erase(removing);
       cleanup_reader_association(lsi->second.subscription_, remove_from, removing);
       remove_assoc_i(remove_from, lsi->second, removing);
       // Update writer
       if (count) {
         write_subscription_data(remove_from, lsi->second);
       }
     }
 
   } else {
     const LocalPublicationIter lpi = local_publications_.find(remove_from);
     if (lpi != local_publications_.end()) {
       lpi->second.matched_endpoints_.erase(removing);
       const DiscoveredSubscriptionIter dsi = discovered_subscriptions_.find(removing);
       if (dsi != discovered_subscriptions_.end()) {
         dsi->second.matched_endpoints_.erase(remove_from);
       }
       lpi->second.remote_expectant_opendds_associations_.erase(removing);
       cleanup_writer_association(lpi->second.publication_, remove_from, removing);
       remove_assoc_i(remove_from, lpi->second, removing);
     }
   }
 }

◆ remove_assoc_i() [1/2]

void OpenDDS::RTPS::Sedp::remove_assoc_i	(	const DCPS::GUID_t &	local_guid,
		const LocalPublication &	lpub,
		const DCPS::GUID_t &	remote_guid
	)

protected

Definition at line 5635 of file Sedp.cpp.

References ice_agent_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), and OpenDDS::RTPS::LocalPublication::publication_.

Referenced by match_continue(), remove_assoc(), and OpenDDS::RTPS::Sedp::SubscriptionAgentInfoListener::SubscriptionAgentInfoListener().

                                                     {
 #ifdef OPENDDS_SECURITY
   DCPS::DataWriterCallbacks_rch pl = lpub.publication_.lock();
   if (pl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
     if (endpoint) {
       ice_agent_->stop_ice(endpoint, local_guid, remote_guid);
     }
   }
 #else
   ACE_UNUSED_ARG(local_guid);
   ACE_UNUSED_ARG(lpub);
   ACE_UNUSED_ARG(remote_guid);
 #endif
 }

◆ remove_assoc_i() [2/2]

void OpenDDS::RTPS::Sedp::remove_assoc_i	(	const DCPS::GUID_t &	local_guid,
		const LocalSubscription &	lsub,
		const DCPS::GUID_t &	remote_guid
	)

protected

Definition at line 5672 of file Sedp.cpp.

References ice_agent_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), and OpenDDS::RTPS::LocalSubscription::subscription_.

                                                     {
 #ifdef OPENDDS_SECURITY
   DCPS::DataReaderCallbacks_rch sl = lsub.subscription_.lock();
   if (sl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
     if (endpoint) {
       ice_agent_->stop_ice(endpoint, local_guid, remote_guid);
     }
   }
 #else
   ACE_UNUSED_ARG(local_guid);
   ACE_UNUSED_ARG(lsub);
   ACE_UNUSED_ARG(remote_guid);
 #endif
 }

◆ remove_entities_belonging_to()

template<typename Map >

void OpenDDS::RTPS::Sedp::remove_entities_belonging_to	(	Map &	m,
		DCPS::GUID_t	participant,
		bool	subscription,
		OPENDDS_VECTOR(typename Map::mapped_type)&	to_remove_from_bit
	)

private

Definition at line 1795 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_UNKNOWN, OpenDDS::DCPS::GUID_t::guidPrefix, LM_DEBUG, match_endpoints(), purge_dead_topic(), OpenDDS::RTPS::Spdp::shutting_down(), spdp_, and topics_.

Referenced by disassociate().

 {
   participant.entityId = ENTITYID_UNKNOWN;
   for (typename Map::iterator i = m.lower_bound(participant);
        i != m.end() && 0 == std::memcmp(i->first.guidPrefix,
                                         participant.guidPrefix,
                                         sizeof(GuidPrefix_t));) {
     String topic_name = i->second.get_topic_name();
     DCPS::TopicDetailsMap::iterator top_it = topics_.find(topic_name);
     if (top_it != topics_.end()) {
       if (subscription) {
         top_it->second.remove_discovered_subscription(i->first);
       } else {
         top_it->second.remove_discovered_publication(i->first);
       }
       if (DCPS::DCPS_debug_level > 3) {
         ACE_DEBUG((LM_DEBUG,
                    ACE_TEXT("(%P|%t) Sedp::remove_entities_belonging_to - ")
                    ACE_TEXT("calling match_endpoints remove\n")));
       }
       match_endpoints(i->first, top_it->second, true /*remove*/);
       if (spdp_.shutting_down()) { return; }
       if (top_it->second.is_dead()) {
         purge_dead_topic(topic_name);
       }
     }
     to_remove_from_bit.push_back(i->second);
     m.erase(i++);
   }
 }

◆ remove_expired_endpoints()

void OpenDDS::RTPS::Sedp::remove_expired_endpoints ( const MonotonicTimePoint & )

protected

Definition at line 6978 of file Sedp.cpp.

References ACE_DEBUG, ACE_GUARD, OpenDDS::DCPS::LogGuid::c_str(), cleanup_type_lookup_data(), OpenDDS::DCPS::DCPS_debug_level, LM_DEBUG, OpenDDS::DCPS::TransportClient::lock_, matching_data_buffer_, max_type_lookup_service_reply_period_, orig_seq_numbers_, and DDS::RETCODE_TIMEOUT.

Referenced by type_lookup_init().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   const MonotonicTimePoint now = MonotonicTimePoint::now();
 
   MatchingDataIter end_iter = matching_data_buffer_.end();
   for (MatchingDataIter iter = matching_data_buffer_.begin(); iter != end_iter; ) {
     // Do not try to simplify increment: "associative container erase idiom"
     if (now - iter->second.time_added_to_map >= max_type_lookup_service_reply_period_) {
       if (DCPS_debug_level >= 4) {
         ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::remove_expired_endpoints: "
           "clean up pending pair local: %C remote: %C\n",
           LogGuid(iter->first.local).c_str(), LogGuid(iter->first.remote).c_str()));
       }
       if (iter->first.type_obj_req_cond) {
         iter->first.type_obj_req_cond->done(DDS::RETCODE_TIMEOUT);
       }
       matching_data_buffer_.erase(iter++);
     } else {
       ++iter;
     }
   }
 
   // Clean up internal data used by getTypeDependencies
   for (OrigSeqNumberMap::iterator it = orig_seq_numbers_.begin(); it != orig_seq_numbers_.end();) {
     if (now - it->second.time_started >= max_type_lookup_service_reply_period_) {
       if (DCPS_debug_level >= 4) {
         ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::remove_expired_endpoints: "
           "clean up type lookup data for %C\n",
           LogGuid(it->second.participant).c_str()));
       }
       cleanup_type_lookup_data(it->second.participant, it->second.type_id, it->second.secure);
       orig_seq_numbers_.erase(it++);
     } else {
       ++it;
     }
   }
 }

◆ remove_from_bit() [1/2]

void OpenDDS::RTPS::Sedp::remove_from_bit ( const DiscoveredPublication & pub )

inlineprotected

Definition at line 1144 of file Sedp.h.

References remove_from_bit_i().

Referenced by ignore(), process_discovered_reader_data(), and process_discovered_writer_data().

   {
     remove_from_bit_i(pub);
   }

◆ remove_from_bit() [2/2]

void OpenDDS::RTPS::Sedp::remove_from_bit ( const DiscoveredSubscription & sub )

inlineprotected

Definition at line 1149 of file Sedp.h.

References remove_from_bit_i().

   {
     remove_from_bit_i(sub);
   }

◆ remove_from_bit_i() [1/2]

void OpenDDS::RTPS::Sedp::remove_from_bit_i ( const DiscoveredPublication & pub )

private

Definition at line 1828 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredPublication::bit_ih_, OpenDDS::RTPS::Spdp::bit_subscriber_, and spdp_.

Referenced by disassociate(), and remove_from_bit().

 {
   spdp_.bit_subscriber_->remove_publication(pub.bit_ih_);
 }

◆ remove_from_bit_i() [2/2]

void OpenDDS::RTPS::Sedp::remove_from_bit_i ( const DiscoveredSubscription & sub )

private

Definition at line 1834 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredSubscription::bit_ih_, OpenDDS::RTPS::Spdp::bit_subscriber_, and spdp_.

 {
   spdp_.bit_subscriber_->remove_subscription(sub.bit_ih_);
 }

◆ remove_publication()

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

Definition at line 6218 of file Sedp.cpp.

References ACE_ERROR, ACE_GUARD, ACE_TEXT(), cleanup_secure_writer(), is_security_enabled(), LM_ERROR, local_publications_, OpenDDS::DCPS::TransportClient::lock_, match_endpoints(), remove_publication_i(), DDS::RETCODE_OK, topic_names_, and topics_.

Referenced by ignoring().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   LocalPublicationIter iter = local_publications_.find(publicationId);
   if (iter != local_publications_.end()) {
     if (DDS::RETCODE_OK == remove_publication_i(publicationId, iter->second)) {
       String topic_name = topic_names_[iter->second.topic_id_];
 #ifdef OPENDDS_SECURITY
       if (is_security_enabled()) {
         cleanup_secure_writer(publicationId);
       }
 #endif
       local_publications_.erase(publicationId);
       DCPS::TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it != topics_.end()) {
         match_endpoints(publicationId, top_it->second, true /*remove*/);
         top_it->second.remove_local_publication(publicationId);
         // Local, no need to check for dead topic.
       }
     } else {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::remove_publication: ")
                  ACE_TEXT("Failed to publish dispose msg\n")));
     }
   }
 }

◆ remove_publication_i()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::remove_publication_i	(	const DCPS::GUID_t &	publicationId,
		LocalPublication &	pub
	)

privatevirtual

Definition at line 1878 of file Sedp.cpp.

References DDS::Security::EndpointSecurityAttributes::base, ice_agent_, DDS::Security::TopicSecurityAttributes::is_discovery_protected, is_security_enabled(), OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalPublication::publication_, publications_secure_writer_, publications_writer_, and OpenDDS::RTPS::LocalEntity::security_attribs_.

Referenced by remove_publication().

 {
 #ifdef OPENDDS_SECURITY
   DCPS::DataWriterCallbacks_rch pl = pub.publication_.lock();
   if (pl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
     if (endpoint) {
       ice_agent_->remove_local_agent_info_listener(endpoint, publicationId);
     }
   }
 
   if (is_security_enabled() && pub.security_attribs_.base.is_discovery_protected) {
     return publications_secure_writer_->write_unregister_dispose(publicationId);
   } else {
     return publications_writer_->write_unregister_dispose(publicationId);
   }
 #else
   ACE_UNUSED_ARG(pub);
   return publications_writer_->write_unregister_dispose(publicationId);
 #endif
 }

◆ remove_remote_crypto_handle()

void OpenDDS::RTPS::Sedp::remove_remote_crypto_handle	(	const DCPS::GUID_t &	participant,
		const EntityId_t &	entity
	)

Definition at line 1421 of file Sedp.cpp.

References ACE_ERROR, ACE_TEXT(), DDS::Security::SecurityException::code, OpenDDS::Security::HandleRegistry::erase_remote_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::erase_remote_datawriter_crypto_handle(), OpenDDS::Security::SecurityConfig::get_crypto_key_factory(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), OpenDDS::RTPS::Spdp::get_security_config(), DDS::HANDLE_NIL, OpenDDS::DCPS::GuidConverter::isReader(), OpenDDS::DCPS::GuidConverter::isWriter(), LM_ERROR, OpenDDS::DCPS::make_id(), DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, OpenDDS::DCPS::security_debug, and spdp_.

Referenced by cleanup_volatile_crypto(), and disassociate().

 {
   using namespace DDS::Security;
 
   const GUID_t remote = make_id(participant, entity);
   SecurityException se = {"", 0, 0};
   CryptoKeyFactory_var key_factory = spdp_.get_security_config()->get_crypto_key_factory();
 
   const DCPS::GuidConverter traits(remote);
   if (traits.isReader()) {
     const DDS::Security::DatareaderCryptoHandle drch =
       get_handle_registry()->get_remote_datareader_crypto_handle(remote);
     if (drch == DDS::HANDLE_NIL) {
       return;
     }
     if (!key_factory->unregister_datareader(drch, se)) {
       if (DCPS::security_debug.cleanup_error) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) {cleanup_error} Sedp::remove_remote_crypto_handle() - ")
                    ACE_TEXT("Failure calling unregister_datareader() (ch %d). Security Exception[%d.%d]: %C\n"),
                    drch, se.code, se.minor_code, se.message.in()));
       }
     }
     get_handle_registry()->erase_remote_datareader_crypto_handle(remote);
   } else if (traits.isWriter()) {
     const DDS::Security::DatawriterCryptoHandle dwch =
       get_handle_registry()->get_remote_datawriter_crypto_handle(remote);
     if (dwch == DDS::HANDLE_NIL) {
       return;
     }
     if (!key_factory->unregister_datawriter(dwch, se)) {
       if (DCPS::security_debug.cleanup_error) {
         ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) {cleanup_error} Sedp::remove_remote_crypto_handle() - ")
                    ACE_TEXT("Failure calling unregister_datawriter() (ch %d). Security Exception[%d.%d]: %C\n"),
                    dwch, se.code, se.minor_code, se.message.in()));
       }
     }
     get_handle_registry()->erase_remote_datawriter_crypto_handle(remote);
   }
 }

◆ remove_subscription()

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

Definition at line 6364 of file Sedp.cpp.

References ACE_ERROR, ACE_GUARD, ACE_TEXT(), cleanup_secure_reader(), is_security_enabled(), LM_ERROR, local_subscriptions_, OpenDDS::DCPS::TransportClient::lock_, match_endpoints(), remove_subscription_i(), DDS::RETCODE_OK, topic_names_, and topics_.

Referenced by ignoring().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   LocalSubscriptionIter iter = local_subscriptions_.find(subscriptionId);
   if (iter != local_subscriptions_.end()) {
     if (DDS::RETCODE_OK == remove_subscription_i(subscriptionId, iter->second)) {
       String topic_name = topic_names_[iter->second.topic_id_];
 #ifdef OPENDDS_SECURITY
       if (is_security_enabled()) {
         cleanup_secure_reader(subscriptionId);
       }
 #endif
       local_subscriptions_.erase(subscriptionId);
       DCPS::TopicDetailsMap::iterator top_it = topics_.find(topic_name);
       if (top_it != topics_.end()) {
         match_endpoints(subscriptionId, top_it->second, true /*remove*/);
         top_it->second.remove_local_subscription(subscriptionId);
         // Local, no need to check for dead topic.
       }
     } else {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::remove_subscription - ")
                  ACE_TEXT("Failed to publish dispose msg\n")));
     }
   }
 }

◆ remove_subscription_i()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::remove_subscription_i	(	const DCPS::GUID_t &	subscriptionId,
		LocalSubscription &	sub
	)

privatevirtual

Definition at line 1927 of file Sedp.cpp.

References DDS::Security::EndpointSecurityAttributes::base, ice_agent_, DDS::Security::TopicSecurityAttributes::is_discovery_protected, is_security_enabled(), OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalEntity::security_attribs_, OpenDDS::RTPS::LocalSubscription::subscription_, subscriptions_secure_writer_, and subscriptions_writer_.

Referenced by remove_subscription().

 {
 #ifdef OPENDDS_SECURITY
   DCPS::DataReaderCallbacks_rch sl = sub.subscription_.lock();
   if (sl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
     if (endpoint) {
       ice_agent_->remove_local_agent_info_listener(endpoint, subscriptionId);
     }
   }
 
   if (is_security_enabled() && sub.security_attribs_.base.is_discovery_protected) {
     return subscriptions_secure_writer_->write_unregister_dispose(subscriptionId);
   } else {
     return subscriptions_writer_->write_unregister_dispose(subscriptionId);
   }
 #else
   ACE_UNUSED_ARG(sub);
   return subscriptions_writer_->write_unregister_dispose(subscriptionId);
 #endif
 }

◆ remove_topic()

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

Definition at line 6105 of file Sedp.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::INTERNAL_ERROR, OpenDDS::DCPS::TopicDetails::is_dead(), OpenDDS::DCPS::TransportClient::lock_, name, OpenDDS::DCPS::NOT_FOUND, purge_dead_topic(), OpenDDS::DCPS::REMOVED, topic_names_, topics_, and OpenDDS::DCPS::TopicDetails::unset_local().

Referenced by ignoring().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, DCPS::INTERNAL_ERROR);
   TopicNameMap::iterator name_iter = topic_names_.find(topicId);
   if (name_iter == topic_names_.end()) {
     return DCPS::NOT_FOUND;
   }
   const String& name = name_iter->second;
   DCPS::TopicDetails& td = topics_[name];
   td.unset_local();
   if (td.is_dead()) {
     purge_dead_topic(name);
   }
 
   return DCPS::REMOVED;
 }

◆ replay_durable_data_for()

void OpenDDS::RTPS::Sedp::replay_durable_data_for ( const DCPS::GUID_t & remote_sub_id )

protected

Definition at line 1634 of file Sedp.cpp.

References ACE_DEBUG, ACE_GUARD, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::DCPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER, OpenDDS::RTPS::ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER, OpenDDS::DCPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER, OpenDDS::RTPS::ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER, LM_DEBUG, lock_, OPENDDS_STRING, write_durable_dcps_participant_secure(), write_durable_participant_message_data(), write_durable_participant_message_data_secure(), write_durable_publication_data(), and write_durable_subscription_data().

Referenced by OpenDDS::RTPS::Sedp::Writer::remove_associations(), OpenDDS::RTPS::Sedp::Writer::replay_durable_data_for(), and OpenDDS::RTPS::Sedp::SubscriptionAgentInfoListener::SubscriptionAgentInfoListener().

 {
   DCPS::GuidConverter conv(remote_sub_id);
   ACE_DEBUG((LM_DEBUG, "Sedp::replay_durable_data_for %C\n", OPENDDS_STRING(conv).c_str()));
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   if (remote_sub_id.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER) {
     write_durable_publication_data(remote_sub_id, false);
   } else if (remote_sub_id.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER) {
     write_durable_subscription_data(remote_sub_id, false);
   } else if (remote_sub_id.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER) {
     write_durable_participant_message_data(remote_sub_id);
 #ifdef OPENDDS_SECURITY
   } else if (remote_sub_id.entityId == ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) {
     write_durable_publication_data(remote_sub_id, true);
   } else if (remote_sub_id.entityId == ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) {
     write_durable_subscription_data(remote_sub_id, true);
   } else if (remote_sub_id.entityId == ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) {
     write_durable_participant_message_data_secure(remote_sub_id);
   } else if (remote_sub_id.entityId == ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER) {
     write_durable_dcps_participant_secure(remote_sub_id);
 #endif
   }
 }

◆ request_remote_complete_type_objects()

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

Definition at line 6925 of file Sedp.cpp.

References ACE_ERROR, discovered_publications_, discovered_subscriptions_, OpenDDS::DCPS::TypeObjReqCond::done(), OpenDDS::DCPS::GuidConverter::isReader(), OpenDDS::DCPS::GuidConverter::isWriter(), LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, request_type_objects(), and DDS::RETCODE_BAD_PARAMETER.

Referenced by transport_inst().

 {
   bool discovered = false;
   bool discovery_protected = false;
   DCPS::GuidConverter gc(remote_entity);
   if (gc.isWriter()) {
     DiscoveredPublicationIter dpi = discovered_publications_.find(remote_entity);
     if (dpi != discovered_publications_.end()) {
       discovered = true;
 #ifdef OPENDDS_SECURITY
       discovery_protected = dpi->second.security_attribs_.base.is_discovery_protected;
 #endif
     }
   } else if (gc.isReader()) {
     DiscoveredSubscriptionIter dsi = discovered_subscriptions_.find(remote_entity);
     if (dsi != discovered_subscriptions_.end()) {
       discovered = true;
 #ifdef OPENDDS_SECURITY
       discovery_protected = dsi->second.security_attribs_.base.is_discovery_protected;
 #endif
     }
   }
 
   if (!discovered) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: Sedp::request_remote_complete_type_objects: ",
         "GUID passed, %C, is not a discovered reader or writer\n",
         String(gc).c_str()));
     }
     cond.done(DDS::RETCODE_BAD_PARAMETER);
     return;
   }
 
   request_type_objects(&remote_type_info, MatchingPair(remote_entity, gc.isReader(), &cond),
     discovery_protected, false, true);
 }

◆ request_type_objects()

void OpenDDS::RTPS::Sedp::request_type_objects	(	const XTypes::TypeInformation *	type_info,
		const MatchingPair &	mp,
		bool	is_discovery_protected,
		bool	get_minimal,
		bool	get_complete
	)

protected

Definition at line 7484 of file Sedp.cpp.

References ACE_DEBUG, OpenDDS::DCPS::LogGuid::c_str(), OpenDDS::XTypes::TypeInformation::complete, OpenDDS::DCPS::DCPS_debug_level, get_remote_type_objects(), OpenDDS::DCPS::SequenceNumber::getValue(), OpenDDS::RTPS::Sedp::MatchingData::got_complete, OpenDDS::RTPS::Sedp::MatchingData::got_minimal, LM_DEBUG, matching_data_buffer_, OpenDDS::XTypes::TypeInformation::minimal, OPENDDS_ASSERT, OpenDDS::DCPS::GuidPair::remote, OpenDDS::RTPS::Sedp::MatchingData::rpc_seqnum_complete, OpenDDS::RTPS::Sedp::MatchingData::rpc_seqnum_minimal, OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN(), OpenDDS::RTPS::Sedp::MatchingData::time_added_to_map, and type_lookup_service_sequence_number_.

Referenced by match(), and request_remote_complete_type_objects().

 {
   OPENDDS_ASSERT(get_minimal || get_complete);
   MatchingData md;
   md.time_added_to_map = MonotonicTimePoint::now();
 
   if (get_minimal) {
     md.rpc_seqnum_minimal = ++type_lookup_service_sequence_number_;
     md.got_minimal = false;
   } else {
     md.rpc_seqnum_minimal = SequenceNumber::SEQUENCENUMBER_UNKNOWN();
     md.got_minimal = true;
   }
 
   if (get_complete) {
     md.rpc_seqnum_complete = ++type_lookup_service_sequence_number_;
     md.got_complete = false;
   } else {
     md.rpc_seqnum_complete = SequenceNumber::SEQUENCENUMBER_UNKNOWN();
     md.got_complete = true;
   }
 
   matching_data_buffer_[mp] = md;
 
   // Send a sequence of requests for minimal remote TypeObjects
   if (get_minimal) {
     if (DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::request_type_objects: minimal remote: %C seq: %q\n",
         LogGuid(mp.remote).c_str(), md.rpc_seqnum_minimal.getValue()));
     }
     get_remote_type_objects(type_info->minimal, md, true, mp.remote, is_discovery_protected);
   }
 
   // Send another sequence of requests for complete remote TypeObjects
   if (get_complete) {
     if (DCPS_debug_level >= 4) {
       ACE_DEBUG((LM_DEBUG, "(%P|%t) Sedp::request_type_objects: complete remote: %C seq: %q\n",
         LogGuid(mp.remote).c_str(), md.rpc_seqnum_complete.getValue()));
     }
     get_remote_type_objects(type_info->complete, md, false, mp.remote, is_discovery_protected);
   }
 }

◆ resend_user_crypto_tokens()

void OpenDDS::RTPS::Sedp::resend_user_crypto_tokens ( const DCPS::GUID_t & remote_participant )

Definition at line 5542 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), create_and_send_datareader_crypto_tokens(), create_and_send_datawriter_crypto_tokens(), OpenDDS::DCPS::ENTITYID_PARTICIPANT, OpenDDS::DCPS::equal_guid_prefixes(), get_handle_registry(), OpenDDS::Security::HandleRegistry::get_local_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_local_datawriter_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datareader_crypto_handle(), OpenDDS::Security::HandleRegistry::get_remote_datawriter_crypto_handle(), DDS::HANDLE_NIL, OpenDDS::DCPS::GuidConverter::isUserDomainEntity(), LM_DEBUG, local_publications_, local_subscriptions_, OpenDDS::DCPS::make_id(), and OpenDDS::DCPS::security_debug.

Referenced by association_complete_i().

 {
   const GUID_t remote_participant = make_id(id, ENTITYID_PARTICIPANT);
 
   if (DCPS::security_debug.bookkeeping) {
     ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {bookkeeping} ")
                ACE_TEXT("Sedp::resend_user_crypto_tokens(%C)\n"),
                DCPS::LogGuid(remote_participant).c_str()));
   }
 
   /*
    * For each user DataReader that has a crypto handle, send tokens to matched
    * DataWriters that have a crypto handle.
    */
 
   for (LocalSubscriptionCIter reader_pos = local_subscriptions_.begin(),
          reader_limit = local_subscriptions_.end();
        reader_pos != reader_limit; ++reader_pos) {
     if (!DCPS::GuidConverter(reader_pos->first).isUserDomainEntity()) {
       continue;
     }
     const DDS::Security::DatareaderCryptoHandle drch =
       get_handle_registry()->get_local_datareader_crypto_handle(reader_pos->first);
     if (drch == DDS::HANDLE_NIL) {
       continue;
     }
     for (DCPS::RepoIdSet::const_iterator writer_pos = reader_pos->second.matched_endpoints_.begin(),
            writer_limit = reader_pos->second.matched_endpoints_.end();
          writer_pos != writer_limit; ++writer_pos) {
       if (!DCPS::equal_guid_prefixes(*writer_pos, remote_participant)) {
         continue;
       }
       const DDS::Security::DatawriterCryptoHandle dwch =
         get_handle_registry()->get_remote_datawriter_crypto_handle(*writer_pos);
       if (dwch == DDS::HANDLE_NIL) {
         continue;
       }
       create_and_send_datareader_crypto_tokens(drch, reader_pos->first, dwch, *writer_pos);
     }
   }
 
   /*
    * For each user DataWriter that has a crypto handle, send tokens to matched
    * DataReaders that have a crypto handle.
    */
   for (LocalPublicationCIter writer_pos = local_publications_.begin(),
          writer_limit = local_publications_.end();
        writer_pos != writer_limit; ++writer_pos) {
     if (!DCPS::GuidConverter(writer_pos->first).isUserDomainEntity()) {
       continue;
     }
     const DDS::Security::DatawriterCryptoHandle dwch =
       get_handle_registry()->get_local_datawriter_crypto_handle(writer_pos->first);
     if (dwch == DDS::HANDLE_NIL) {
       continue;
     }
     for (DCPS::RepoIdSet::const_iterator reader_pos = writer_pos->second.matched_endpoints_.begin(),
            reader_limit = writer_pos->second.matched_endpoints_.end();
          reader_pos != reader_limit; ++reader_pos) {
       if (!DCPS::equal_guid_prefixes(*reader_pos, remote_participant)) {
         continue;
       }
       const DDS::Security::DatareaderCryptoHandle drch =
         get_handle_registry()->get_remote_datareader_crypto_handle(*reader_pos);
       if (drch == DDS::HANDLE_NIL) {
         continue;
       }
       create_and_send_datawriter_crypto_tokens(dwch, writer_pos->first, drch, *reader_pos);
     }
   }
 }

◆ rtps_relay_address()

void OpenDDS::RTPS::Sedp::rtps_relay_address ( const ACE_INET_Addr & address )

Definition at line 5958 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::DCPS::static_rchandle_cast(), and transport_inst_.

 {
   DCPS::RtpsUdpInst_rch rtps_inst = DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   {
     ACE_GUARD(ACE_Thread_Mutex, g, rtps_inst->config_lock_);
     rtps_inst->rtps_relay_address_ = address;
   }
   rtps_inst->rtps_relay_address_change();
 }

◆ rtps_relay_only_now()

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

Definition at line 5905 of file Sedp.cpp.

References OpenDDS::DCPS::TransportInst::rtps_relay_only_now(), and transport_inst_.

 {
   transport_inst_->rtps_relay_only_now(f);
 }

◆ send_builtin_crypto_tokens() [1/2]

void OpenDDS::RTPS::Sedp::send_builtin_crypto_tokens ( const DCPS::GUID_t & remoteId )

Definition at line 1512 of file Sedp.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::DCPS::ENTITYID_PARTICIPANT, LM_ERROR, OpenDDS::RTPS::BuiltinAssociationRecord::local_id(), OpenDDS::RTPS::BuiltinAssociationRecord::local_tokens_sent(), OpenDDS::DCPS::make_id(), OpenDDS::RTPS::Spdp::participants_, OpenDDS::RTPS::BuiltinAssociationRecord::remote_id(), OpenDDS::DCPS::security_debug, OpenDDS::RTPS::BuiltinAssociationRecord::send_local_token(), and spdp_.

Referenced by association_complete_i().

 {
   const GUID_t remote_part = make_id(remoteId, ENTITYID_PARTICIPANT);
   Spdp::DiscoveredParticipantIter iter = spdp_.participants_.find(remote_part);
   if (iter == spdp_.participants_.end()) {
     if (DCPS::security_debug.bookkeeping) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) {bookkeeping} Sedp::send_builtin_crypto_tokens - could not find participant %C\n"), LogGuid(remote_part).c_str()));
     }
     return;
   }
 
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = iter->second.builtin_pending_records_.begin(),
          limit = iter->second.builtin_pending_records_.end(); pos != limit; ++pos) {
     BuiltinAssociationRecord& record = *pos;
     if (record.send_local_token()) {
       send_builtin_crypto_tokens(record.remote_id(), record.local_id());
       record.local_tokens_sent(true);
     }
   }
 
   for (DiscoveredParticipant::BuiltinAssociationRecords::iterator pos = iter->second.builtin_associated_records_.begin(),
          limit = iter->second.builtin_associated_records_.end(); pos != limit; ++pos) {
     BuiltinAssociationRecord& record = *pos;
     if (record.send_local_token()) {
       send_builtin_crypto_tokens(record.remote_id(), record.local_id());
       record.local_tokens_sent(true);
     }
   }
 }

◆ send_builtin_crypto_tokens() [2/2]

void OpenDDS::RTPS::Sedp::send_builtin_crypto_tokens	(	const DCPS::GUID_t &	dst,
		const DCPS::GUID_t &	src
	)

Create and send keys for individual endpoints.

Definition at line 1500 of file Sedp.cpp.

References create_and_send_datareader_crypto_tokens(), create_and_send_datawriter_crypto_tokens(), and get_handle_registry().

 {
   if (DCPS::GuidConverter(src).isReader()) {
     create_and_send_datareader_crypto_tokens(get_handle_registry()->get_local_datareader_crypto_handle(src), src,
                                              get_handle_registry()->get_remote_datawriter_crypto_handle(dst), dst);
   } else {
     create_and_send_datawriter_crypto_tokens(get_handle_registry()->get_local_datawriter_crypto_handle(src), src,
                                              get_handle_registry()->get_remote_datareader_crypto_handle(dst), dst);
   }
 }

◆ send_datareader_crypto_tokens()

void OpenDDS::RTPS::Sedp::send_datareader_crypto_tokens	(	const DCPS::GUID_t &	local_reader,
		const DCPS::GUID_t &	remote_writer,
		const DDS::Security::DatareaderCryptoTokenSeq &	drcts
	)

protected

Definition at line 5341 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), 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_DATAREADER_CRYPTO_TOKENS, LM_WARNING, OpenDDS::DCPS::make_id(), DDS::Security::ParticipantGenericMessage::message_class_id, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, participant_id_, DDS::Security::ParticipantGenericMessage::related_message_identity, DDS::RETCODE_OK, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, DDS::Security::MessageIdentity::source_guid, and write_volatile_message().

Referenced by create_and_send_datareader_crypto_tokens().

 {
   if (drcts.length() != 0) {
     const DCPS::GUID_t remote_part = make_id(remote_writer, ENTITYID_PARTICIPANT);
     const DCPS::GUID_t local_volatile_writer = make_id(
       participant_id_, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
     const DCPS::GUID_t remote_volatile_reader = make_id(
       remote_part, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
 
     DDS::Security::ParticipantVolatileMessageSecure msg;
     msg.message_identity.source_guid = local_volatile_writer;
     msg.message_class_id = DDS::Security::GMCLASSID_SECURITY_DATAREADER_CRYPTO_TOKENS;
     msg.destination_participant_guid = remote_part;
     msg.destination_endpoint_guid = remote_writer;
     msg.source_endpoint_guid = local_reader;
     msg.message_data = reinterpret_cast<const DDS::Security::DataHolderSeq&>(drcts);
     msg.related_message_identity = DDS::Security::MessageIdentity();
 
     if (write_volatile_message(msg, remote_volatile_reader) != DDS::RETCODE_OK) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::send_datareader_crypto_tokens() - ")
         ACE_TEXT("Unable to write volatile message.\n")));
     }
   }
 }

◆ send_datawriter_crypto_tokens()

void OpenDDS::RTPS::Sedp::send_datawriter_crypto_tokens	(	const DCPS::GUID_t &	local_writer,
		const DCPS::GUID_t &	remote_reader,
		const DDS::Security::DatawriterCryptoTokenSeq &	dwcts
	)

protected

Definition at line 5385 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), 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_DATAWRITER_CRYPTO_TOKENS, LM_WARNING, OpenDDS::DCPS::make_id(), DDS::Security::ParticipantGenericMessage::message_class_id, DDS::Security::ParticipantGenericMessage::message_data, DDS::Security::ParticipantGenericMessage::message_identity, participant_id_, DDS::Security::ParticipantGenericMessage::related_message_identity, DDS::RETCODE_OK, DDS::Security::ParticipantGenericMessage::source_endpoint_guid, DDS::Security::MessageIdentity::source_guid, and write_volatile_message().

Referenced by create_and_send_datawriter_crypto_tokens().

 {
   if (dwcts.length() != 0) {
     const DCPS::GUID_t remote_part = make_id(remote_reader, ENTITYID_PARTICIPANT);
     const DCPS::GUID_t local_volatile_writer = make_id(
       participant_id_, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER);
     const DCPS::GUID_t remote_volatile_reader = make_id(
       remote_part, ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER);
 
     DDS::Security::ParticipantVolatileMessageSecure msg;
     msg.message_identity.source_guid = local_volatile_writer;
     msg.message_class_id = DDS::Security::GMCLASSID_SECURITY_DATAWRITER_CRYPTO_TOKENS;
     msg.destination_participant_guid = remote_part;
     msg.destination_endpoint_guid = remote_reader;
     msg.source_endpoint_guid = local_writer;
     msg.message_data = reinterpret_cast<const DDS::Security::DataHolderSeq&>(dwcts);
     msg.related_message_identity = DDS::Security::MessageIdentity();
 
     if (write_volatile_message(msg, remote_volatile_reader) != DDS::RETCODE_OK) {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::send_datawriter_crypto_tokens() - ")
         ACE_TEXT("Unable to write volatile message.\n")));
     }
   }
 }

◆ send_type_lookup_request()

bool OpenDDS::RTPS::Sedp::send_type_lookup_request	(	const XTypes::TypeIdentifierSeq &	type_ids,
		const DCPS::GUID_t &	reader,
		bool	is_discovery_protected,
		bool	send_get_types,
		const SequenceNumber &	seq_num
	)

Definition at line 3064 of file Sedp.cpp.

References OpenDDS::DCPS::ENTITYID_TL_SVC_REQ_READER, OpenDDS::RTPS::ENTITYID_TL_SVC_REQ_READER_SECURE, is_security_enabled(), OpenDDS::DCPS::make_id(), type_lookup_request_secure_writer_, type_lookup_request_writer_, OpenDDS::XTypes::TypeLookup_getDependencies_HashId, and OpenDDS::XTypes::TypeLookup_getTypes_HashId.

Referenced by get_remote_type_objects(), OpenDDS::RTPS::Sedp::TypeLookupReplyReader::process_get_dependencies_reply(), and OpenDDS::RTPS::Sedp::TypeLookupRequestWriter::TypeLookupRequestWriter().

 {
   TypeLookupRequestWriter_rch writer = type_lookup_request_writer_;
   DCPS::GUID_t remote_reader = make_id(reader, ENTITYID_TL_SVC_REQ_READER);
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled() && is_discovery_protected) {
     writer = type_lookup_request_secure_writer_;
     remote_reader = make_id(reader, ENTITYID_TL_SVC_REQ_READER_SECURE);
   }
 #else
   ACE_UNUSED_ARG(is_discovery_protected);
 #endif
 
   return writer->send_type_lookup_request(
     type_ids, remote_reader, seq_num,
     send_get_types ?
       XTypes::TypeLookup_getTypes_HashId : XTypes::TypeLookup_getDependencies_HashId);
 }

◆ set_access_control()

void OpenDDS::RTPS::Sedp::set_access_control ( DDS::Security::AccessControl_var acl )

inlineprotected

Definition at line 1191 of file Sedp.h.

References access_control_.

Referenced by init_security().

   {
     access_control_ = acl;
   }

◆ set_crypto_key_exchange()

void OpenDDS::RTPS::Sedp::set_crypto_key_exchange ( DDS::Security::CryptoKeyExchange_var ckf )

inlineprotected

Definition at line 1211 of file Sedp.h.

References crypto_key_exchange_.

Referenced by init_security().

   {
     crypto_key_exchange_ = ckf;
   }

◆ set_crypto_key_factory()

void OpenDDS::RTPS::Sedp::set_crypto_key_factory ( DDS::Security::CryptoKeyFactory_var ckf )

inlineprotected

Definition at line 1201 of file Sedp.h.

References crypto_key_factory_.

Referenced by init_security().

   {
     crypto_key_factory_ = ckf;
   }

◆ set_handle_registry()

void OpenDDS::RTPS::Sedp::set_handle_registry ( const Security::HandleRegistry_rch & hr )

inlineprotected

Definition at line 1221 of file Sedp.h.

References handle_registry_.

Referenced by init_security().

   {
     handle_registry_ = hr;
   }

◆ set_inline_qos()

void OpenDDS::RTPS::Sedp::set_inline_qos ( DCPS::TransportLocatorSeq & locators )

staticprivate

Definition at line 5159 of file Sedp.cpp.

References OPENDDS_STRING, and OpenDDS::DCPS::push_back().

Referenced by OpenDDS::RTPS::Sedp::DiscoveryReader::data_received_i().

 {
   const OPENDDS_STRING rtps_udp = "rtps_udp";
   for (CORBA::ULong i = 0; i < locators.length(); ++i) {
     if (locators[i].transport_type.in() == rtps_udp) {
       DCPS::push_back(locators[i].data, CORBA::Octet(1));
     }
   }
 }

◆ set_permissions_handle()

void OpenDDS::RTPS::Sedp::set_permissions_handle ( DDS::Security::PermissionsHandle h )

inlineprotected

Definition at line 1181 of file Sedp.h.

References permissions_handle_.

Referenced by init_security().

   {
     permissions_handle_ = h;
   }

◆ should_drop_message()

bool OpenDDS::RTPS::Sedp::should_drop_message ( const char * unsecure_topic_name )

private

Definition at line 2825 of file Sedp.cpp.

References get_access_control(), get_permissions_handle(), DDS::Security::TopicSecurityAttributes::is_discovery_protected, and is_security_enabled().

Referenced by data_received().

 {
   if (is_security_enabled()) {
     DDS::Security::TopicSecurityAttributes attribs;
     DDS::Security::SecurityException ex = {"", 0, 0};
 
     bool ok = get_access_control()->get_topic_sec_attributes(
       get_permissions_handle(),
       unsecure_topic_name,
       attribs,
       ex);
 
     if (!ok || attribs.is_discovery_protected) {
       return true;
     }
   }
 
   return false;
 }

◆ should_drop_stateless_message()

bool OpenDDS::RTPS::Sedp::should_drop_stateless_message ( const DDS::Security::ParticipantGenericMessage & msg )

private

Definition at line 2752 of file Sedp.cpp.

References ACE_GUARD_RETURN, DDS::Security::ParticipantGenericMessage::destination_endpoint_guid, DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::DCPS::GUID_UNKNOWN, ignoring(), lock_, participant_id_, participant_stateless_message_reader_, and DDS::Security::ParticipantGenericMessage::source_endpoint_guid.

Referenced by received_stateless_message().

 {
   using DCPS::GUID_UNKNOWN;
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, true);
 
   const GUID_t& src_endpoint = msg.source_endpoint_guid;
   const GUID_t& dst_endpoint = msg.destination_endpoint_guid;
   const GUID_t& this_endpoint = participant_stateless_message_reader_->get_guid();
   const GUID_t& dst_participant = msg.destination_participant_guid;
   const GUID_t& this_participant = participant_id_;
 
   if (ignoring(src_endpoint)) {
     return true;
   }
 
   if (dst_participant != GUID_UNKNOWN && dst_participant != this_participant) {
     return true;
   }
 
   if (dst_endpoint != GUID_UNKNOWN && dst_endpoint != this_endpoint) {
     return true;
   }
 
   return false;
 }

◆ should_drop_volatile_message()

bool OpenDDS::RTPS::Sedp::should_drop_volatile_message ( const DDS::Security::ParticipantGenericMessage & msg )

private

Definition at line 2779 of file Sedp.cpp.

References ACE_DEBUG, ACE_GUARD_RETURN, ACE_TEXT(), DDS::Security::ParticipantGenericMessage::destination_participant_guid, OpenDDS::DCPS::GUID_UNKNOWN, ignoring(), LM_DEBUG, lock_, DDS::Security::ParticipantGenericMessage::message_data, participant_id_, OpenDDS::DCPS::security_debug, and DDS::Security::ParticipantGenericMessage::source_endpoint_guid.

Referenced by received_volatile_message_secure().

 {
   using DCPS::GUID_UNKNOWN;
 
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, true);
 
   const GUID_t src_endpoint = msg.source_endpoint_guid;
   const GUID_t dst_participant = msg.destination_participant_guid;
   const GUID_t this_participant = participant_id_;
 
   if (ignoring(src_endpoint)) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Sedp::should_drop_volatile_message() - ")
                  ACE_TEXT("ignoring %C -> %C local %C\n"),
                  DCPS::LogGuid(src_endpoint).c_str(),
                  DCPS::LogGuid(dst_participant).c_str(),
                  DCPS::LogGuid(this_participant).c_str()));
     }
     return true;
   }
 
   if (!msg.message_data.length()) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Sedp::should_drop_volatile_message() - ")
                  ACE_TEXT("no data %C -> %C local %C\n"),
                  DCPS::LogGuid(src_endpoint).c_str(),
                  DCPS::LogGuid(dst_participant).c_str(),
                  DCPS::LogGuid(this_participant).c_str()));
     }
     return true;
   }
 
   if (dst_participant != GUID_UNKNOWN && dst_participant != this_participant) {
     if (DCPS::security_debug.auth_debug) {
       ACE_DEBUG((LM_DEBUG, ACE_TEXT("(%P|%t) {auth_debug} DEBUG: Sedp::should_drop_volatile_message() - ")
                  ACE_TEXT("not for us %C -> %C local %C\n"),
                  DCPS::LogGuid(src_endpoint).c_str(),
                  DCPS::LogGuid(dst_participant).c_str(),
                  DCPS::LogGuid(this_participant).c_str()));
     }
     return true;
   }
 
   return false;
 }

◆ shutdown()

void OpenDDS::RTPS::Sedp::shutdown ( void )

Definition at line 2008 of file Sedp.cpp.

References dcps_participant_secure_reader_, dcps_participant_secure_writer_, participant_message_reader_, participant_message_secure_reader_, participant_message_secure_writer_, participant_message_writer_, participant_stateless_message_reader_, participant_stateless_message_writer_, participant_volatile_message_secure_reader_, participant_volatile_message_secure_writer_, publications_reader_, publications_secure_reader_, publications_secure_writer_, publications_writer_, subscriptions_reader_, subscriptions_secure_reader_, subscriptions_secure_writer_, subscriptions_writer_, type_lookup_reply_reader_, type_lookup_reply_secure_reader_, type_lookup_reply_secure_writer_, type_lookup_reply_writer_, type_lookup_request_reader_, type_lookup_request_secure_reader_, type_lookup_request_secure_writer_, and type_lookup_request_writer_.

 {
   publications_reader_->shutting_down();
   subscriptions_reader_->shutting_down();
   participant_message_reader_->shutting_down();
   type_lookup_request_reader_->shutting_down();
   type_lookup_reply_reader_->shutting_down();
 #ifdef OPENDDS_SECURITY
   publications_secure_reader_->shutting_down();
   subscriptions_secure_reader_->shutting_down();
   participant_message_secure_reader_->shutting_down();
   participant_stateless_message_reader_->shutting_down();
   participant_volatile_message_secure_reader_->shutting_down();
   dcps_participant_secure_reader_->shutting_down();
   type_lookup_request_secure_reader_->shutting_down();
   type_lookup_reply_secure_reader_->shutting_down();
 #endif
   publications_writer_->shutting_down();
   subscriptions_writer_->shutting_down();
   participant_message_writer_->shutting_down();
   type_lookup_request_writer_->shutting_down();
   type_lookup_reply_writer_->shutting_down();
 #ifdef OPENDDS_SECURITY
   publications_secure_writer_->shutting_down();
   subscriptions_secure_writer_->shutting_down();
   participant_message_secure_writer_->shutting_down();
   participant_stateless_message_writer_->shutting_down();
   participant_volatile_message_secure_writer_->shutting_down();
   dcps_participant_secure_writer_->shutting_down();
   type_lookup_request_secure_writer_->shutting_down();
   type_lookup_reply_secure_writer_->shutting_down();
 #endif
 }

◆ shutting_down()

bool OpenDDS::RTPS::Sedp::shutting_down ( void ) const

privatevirtual

Definition at line 5170 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::shutting_down(), and spdp_.

 {
   return spdp_.shutting_down();
 }

◆ signal_liveliness()

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

Definition at line 2997 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), DDS::Security::SecurityException::code, get_access_control(), get_permissions_handle(), DDS::Security::TopicSecurityAttributes::is_liveliness_protected, is_security_enabled(), LM_WARNING, DDS::Security::SecurityException::message, DDS::Security::SecurityException::minor_code, signal_liveliness_secure(), and signal_liveliness_unsecure().

 {
 
 #ifdef OPENDDS_SECURITY
   DDS::Security::SecurityException se = {"", 0, 0};
   DDS::Security::TopicSecurityAttributes attribs;
 
   if (is_security_enabled()) {
     // TODO: Pending issue DDSSEC12-28 Topic security attributes
     // may get changed to a different set of security attributes.
     bool ok = get_access_control()->get_topic_sec_attributes(
       get_permissions_handle(), "DCPSParticipantMessageSecure", attribs, se);
 
     if (ok) {
 
       if (attribs.is_liveliness_protected) {
         signal_liveliness_secure(kind);
 
       } else {
         signal_liveliness_unsecure(kind);
       }
 
     } else {
       ACE_DEBUG((LM_WARNING, ACE_TEXT("(%P|%t) WARNING: Sedp::signal_liveliness() - ")
         ACE_TEXT("Failure calling get_topic_sec_attributes(). Security Exception[%d.%d]: %C\n"),
           se.code, se.minor_code, se.message.in()));
     }
 
   } else {
 #endif
 
     signal_liveliness_unsecure(kind);
 
 #ifdef OPENDDS_SECURITY
   }
 #endif
 }

◆ signal_liveliness_secure()

void OpenDDS::RTPS::Sedp::signal_liveliness_secure ( DDS::LivelinessQosPolicyKind kind )

Definition at line 3089 of file Sedp.cpp.

References DDS::AUTOMATIC_LIVELINESS_QOS, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER, OpenDDS::DCPS::GUID_UNKNOWN, local_participant_automatic_liveliness_sn_secure_, local_participant_manual_liveliness_sn_secure_, OpenDDS::DCPS::make_id(), DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS, DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS, participant_id_, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE, spdp_, and write_participant_message_data_secure().

Referenced by signal_liveliness().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER)) {
     return;
   }
 
   switch (kind) {
   case DDS::AUTOMATIC_LIVELINESS_QOS: {
     const GUID_t guid = make_id(participant_id_,
       PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE);
     write_participant_message_data_secure(guid, local_participant_automatic_liveliness_sn_secure_, GUID_UNKNOWN);
     break;
   }
 
   case DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS: {
     const GUID_t guid = make_id(participant_id_,
       PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE);
     write_participant_message_data_secure(guid, local_participant_manual_liveliness_sn_secure_, GUID_UNKNOWN);
     break;
   }
 
   case DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS:
     // Do nothing.
     break;
   }
 }

◆ signal_liveliness_unsecure()

void OpenDDS::RTPS::Sedp::signal_liveliness_unsecure ( DDS::LivelinessQosPolicyKind kind )

Definition at line 3036 of file Sedp.cpp.

References DDS::AUTOMATIC_LIVELINESS_QOS, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER, OpenDDS::DCPS::GUID_UNKNOWN, local_participant_automatic_liveliness_sn_, local_participant_manual_liveliness_sn_, OpenDDS::DCPS::make_id(), DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS, DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS, participant_id_, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE, spdp_, and write_participant_message_data().

Referenced by signal_liveliness().

 {
   if (!(spdp_.available_builtin_endpoints() & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER)) {
     return;
   }
 
   switch (kind) {
   case DDS::AUTOMATIC_LIVELINESS_QOS: {
     const GUID_t guid = make_id(participant_id_,
       PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE);
     write_participant_message_data(guid, local_participant_automatic_liveliness_sn_, GUID_UNKNOWN);
     break;
   }
 
   case DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS: {
     const GUID_t guid = make_id(participant_id_,
       PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE);
     write_participant_message_data(guid, local_participant_manual_liveliness_sn_, GUID_UNKNOWN);
     break;
   }
 
   case DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS:
     // Do nothing.
     break;
   }
 }

◆ start_ice() [1/4]

void OpenDDS::RTPS::Sedp::start_ice	(	const DCPS::GUID_t &	guid,
		const LocalPublication &	lpub
	)

protected

Definition at line 5740 of file Sedp.cpp.

References discovered_subscriptions_, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, ice_agent_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalEntity::matched_endpoints_, and OpenDDS::RTPS::LocalPublication::publication_.

Referenced by add_publication_i(), add_subscription_i(), process_discovered_reader_data(), process_discovered_writer_data(), OpenDDS::RTPS::Sedp::SubscriptionAgentInfoListener::SubscriptionAgentInfoListener(), and use_ice_now().

                                                                     {
 #ifdef OPENDDS_SECURITY
   DCPS::DataWriterCallbacks_rch pl = lpub.publication_.lock();
   if (pl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
 
     if (!endpoint || !lpub.have_ice_agent_info) {
       return;
     }
 
     for (DCPS::RepoIdSet::const_iterator it = lpub.matched_endpoints_.begin(),
            end = lpub.matched_endpoints_.end(); it != end; ++it) {
       DiscoveredSubscriptionIter dsi = discovered_subscriptions_.find(*it);
       if (dsi != discovered_subscriptions_.end()) {
         if (dsi->second.have_ice_agent_info_) {
           ice_agent_->start_ice(endpoint, guid, dsi->first, dsi->second.ice_agent_info_);
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(lpub);
 #endif
 }

◆ start_ice() [2/4]

void OpenDDS::RTPS::Sedp::start_ice	(	const DCPS::GUID_t &	guid,
		const LocalSubscription &	lsub
	)

protected

Definition at line 5767 of file Sedp.cpp.

References discovered_publications_, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, ice_agent_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::RTPS::LocalEntity::matched_endpoints_, and OpenDDS::RTPS::LocalSubscription::subscription_.

                                                                      {
 #ifdef OPENDDS_SECURITY
   DCPS::DataReaderCallbacks_rch sl = lsub.subscription_.lock();
   if (sl) {
     DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
 
     if (!endpoint || !lsub.have_ice_agent_info) {
       return;
     }
 
     for (DCPS::RepoIdSet::const_iterator it = lsub.matched_endpoints_.begin(),
            end = lsub.matched_endpoints_.end(); it != end; ++it) {
       DiscoveredPublicationIter dpi = discovered_publications_.find(*it);
       if (dpi != discovered_publications_.end()) {
         if (dpi->second.have_ice_agent_info_) {
           ice_agent_->start_ice(endpoint, guid, dpi->first, dpi->second.ice_agent_info_);
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(lsub);
 #endif
 }

◆ start_ice() [3/4]

void OpenDDS::RTPS::Sedp::start_ice	(	const DCPS::GUID_t &	guid,
		const DiscoveredPublication &	dpub
	)

protected

Definition at line 5794 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredPublication::have_ice_agent_info_, ice_agent_, OpenDDS::RTPS::DiscoveredPublication::ice_agent_info_, local_subscriptions_, and OpenDDS::RTPS::DiscoveredPublication::matched_endpoints_.

                                                                          {
 #ifdef OPENDDS_SECURITY
   if (!dpub.have_ice_agent_info_) {
     return;
   }
 
   for (DCPS::RepoIdSet::const_iterator it = dpub.matched_endpoints_.begin(),
        end = dpub.matched_endpoints_.end(); it != end; ++it) {
     LocalSubscriptionIter lsi = local_subscriptions_.find(*it);
     if (lsi != local_subscriptions_.end() &&
         lsi->second.matched_endpoints_.count(guid)) {
       DCPS::DataReaderCallbacks_rch sl = lsi->second.subscription_.lock();
       if (sl) {
         DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
         if (endpoint) {
           ice_agent_->start_ice(endpoint, lsi->first, guid, dpub.ice_agent_info_);
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(dpub);
 #endif
 }

◆ start_ice() [4/4]

void OpenDDS::RTPS::Sedp::start_ice	(	const DCPS::GUID_t &	guid,
		const DiscoveredSubscription &	dsub
	)

protected

Definition at line 5821 of file Sedp.cpp.

References OpenDDS::RTPS::DiscoveredSubscription::have_ice_agent_info_, ice_agent_, OpenDDS::RTPS::DiscoveredSubscription::ice_agent_info_, OpenDDS::DCPS::GuidConverter::isWriter(), local_publications_, and OpenDDS::RTPS::DiscoveredSubscription::matched_endpoints_.

                                                                           {
 #ifdef OPENDDS_SECURITY
   if (!dsub.have_ice_agent_info_) {
     return;
   }
 
   for (DCPS::RepoIdSet::const_iterator it = dsub.matched_endpoints_.begin(),
        end = dsub.matched_endpoints_.end(); it != end; ++it) {
     const DCPS::GuidConverter conv(*it);
     if (conv.isWriter()) {
       LocalPublicationIter lpi = local_publications_.find(*it);
       if (lpi != local_publications_.end() &&
           lpi->second.matched_endpoints_.count(guid)) {
         DCPS::DataWriterCallbacks_rch pl = lpi->second.publication_.lock();
         if (pl) {
           DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
           if (endpoint) {
             ice_agent_->start_ice(endpoint, lpi->first, guid, dsub.ice_agent_info_);
           }
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(dsub);
 #endif
 }

◆ stop_ice() [1/2]

void OpenDDS::RTPS::Sedp::stop_ice	(	const DCPS::GUID_t &	guid,
		const DiscoveredPublication &	dpub
	)

protected

Definition at line 5851 of file Sedp.cpp.

References ice_agent_, OpenDDS::DCPS::GuidConverter::isReader(), local_subscriptions_, and OpenDDS::RTPS::DiscoveredPublication::matched_endpoints_.

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

 {
 #ifdef OPENDDS_SECURITY
   for (DCPS::RepoIdSet::const_iterator it = dpub.matched_endpoints_.begin(),
        end = dpub.matched_endpoints_.end(); it != end; ++it) {
     const DCPS::GuidConverter conv(*it);
     if (conv.isReader()) {
       LocalSubscriptionIter lsi = local_subscriptions_.find(*it);
       if (lsi != local_subscriptions_.end() &&
           lsi->second.matched_endpoints_.count(guid)) {
         DCPS::DataReaderCallbacks_rch sl = lsi->second.subscription_.lock();
         if (sl) {
           DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
           if (endpoint) {
             ice_agent_->stop_ice(endpoint, lsi->first, guid);
           }
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(dpub);
 #endif
 }

◆ stop_ice() [2/2]

void OpenDDS::RTPS::Sedp::stop_ice	(	const DCPS::GUID_t &	guid,
		const DiscoveredSubscription &	dsub
	)

protected

Definition at line 5878 of file Sedp.cpp.

References ice_agent_, OpenDDS::DCPS::GuidConverter::isWriter(), local_publications_, and OpenDDS::RTPS::DiscoveredSubscription::matched_endpoints_.

 {
 #ifdef OPENDDS_SECURITY
   for (DCPS::RepoIdSet::const_iterator it = dsub.matched_endpoints_.begin(),
        end = dsub.matched_endpoints_.end(); it != end; ++it) {
     const DCPS::GuidConverter conv(*it);
     if (conv.isWriter()) {
       LocalPublicationIter lpi = local_publications_.find(*it);
       if (lpi != local_publications_.end() &&
           lpi->second.matched_endpoints_.count(guid)) {
         DCPS::DataWriterCallbacks_rch pl = lpi->second.publication_.lock();
         if (pl) {
           DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
           if (endpoint) {
             ice_agent_->stop_ice(endpoint, lpi->first, guid);
           }
         }
       }
     }
   }
 #else
   ACE_UNUSED_ARG(guid);
   ACE_UNUSED_ARG(dsub);
 #endif
 }

◆ stun_server_address()

void OpenDDS::RTPS::Sedp::stun_server_address ( const ACE_INET_Addr & address )

Definition at line 5969 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::DCPS::static_rchandle_cast(), and transport_inst_.

 {
   DCPS::RtpsUdpInst_rch rtps_inst = DCPS::static_rchandle_cast<DCPS::RtpsUdpInst>(transport_inst_);
   ACE_GUARD(ACE_Thread_Mutex, g, rtps_inst->config_lock_);
   rtps_inst->stun_server_address_ = address;
 }

◆ transport_inst()

RcHandle<DCPS::TransportInst> OpenDDS::RTPS::Sedp::transport_inst ( ) const

inline

Definition at line 263 of file Sedp.h.

References OPENDDS_MAP_CMP(), request_remote_complete_type_objects(), and transport_inst_.

263 { return transport_inst_; }

OpenDDS::RTPS::Sedp::transport_inst_

DCPS::TransportInst_rch transport_inst_

Definition: Sedp.h:770

◆ type_lookup_fini()

void OpenDDS::RTPS::Sedp::type_lookup_fini ( )

inlineprivate

Definition at line 299 of file Sedp.h.

References type_lookup_reply_deadline_processor_.

Referenced by ~Sedp().

   {
     if (type_lookup_reply_deadline_processor_) {
       type_lookup_reply_deadline_processor_->cancel();
       type_lookup_reply_deadline_processor_.reset();
     }
   }

◆ type_lookup_init()

void OpenDDS::RTPS::Sedp::type_lookup_init ( DCPS::ReactorInterceptor_rch reactor_interceptor )

inlineprivate

Definition at line 290 of file Sedp.h.

References OpenDDS::DCPS::rchandle_from(), remove_expired_endpoints(), TheServiceParticipant, and type_lookup_reply_deadline_processor_.

Referenced by init().

   {
     if (!type_lookup_reply_deadline_processor_) {
       type_lookup_reply_deadline_processor_ =
         DCPS::make_rch<EndpointManagerSporadic>(TheServiceParticipant->time_source(), reactor_interceptor,
                                                 rchandle_from(this), &Sedp::remove_expired_endpoints);
     }
   }

◆ unicast_locators()

DCPS::LocatorSeq OpenDDS::RTPS::Sedp::unicast_locators ( ) const

Definition at line 912 of file Sedp.cpp.

References OpenDDS::DCPS::CONNINFO_UNICAST, OpenDDS::DCPS::TransportInst::populate_locator(), transport_inst_, and OpenDDS::RTPS::transport_locator_to_locator_seq().

 {
   DCPS::TransportLocator trans_info;
   transport_inst_->populate_locator(trans_info, DCPS::CONNINFO_UNICAST);
   return transport_locator_to_locator_seq(trans_info);
 }

◆ update_locators()

void OpenDDS::RTPS::Sedp::update_locators ( const ParticipantData_t & pdata )

Definition at line 1659 of file Sedp.cpp.

 {
   DCPS::TransportLocatorSeq remote_data;
   populate_locators(remote_data, pdata);
 
   DCPS::GUID_t remote_id = make_id(pdata.participantProxy.guidPrefix, ENTITYID_PARTICIPANT);
 
   if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::update_locators updating locators for %C\n"), DCPS::LogGuid(remote_id).c_str()));
   }
 
   const BuiltinEndpointSet_t& avail =
     pdata.participantProxy.availableBuiltinEndpoints;
 
   if (avail & DISC_BUILTIN_ENDPOINT_PARTICIPANT_ANNOUNCER) {
     remote_id.entityId = ENTITYID_SPDP_BUILTIN_PARTICIPANT_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_PARTICIPANT_DETECTOR) {
     remote_id.entityId = ENTITYID_SPDP_BUILTIN_PARTICIPANT_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_PUBLICATION_DETECTOR) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_DETECTOR) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_READER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_WRITER) {
     remote_id.entityId = ENTITYID_TL_SVC_REQ_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REQUEST_DATA_READER) {
     remote_id.entityId = ENTITYID_TL_SVC_REQ_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_WRITER) {
     remote_id.entityId = ENTITYID_TL_SVC_REPLY_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & BUILTIN_ENDPOINT_TYPE_LOOKUP_REPLY_DATA_READER) {
     remote_id.entityId = ENTITYID_TL_SVC_REPLY_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
 
 #ifdef OPENDDS_SECURITY
   if (avail & DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_READER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER) {
     remote_id.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_MESSAGE_SECURE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_STATELESS_MESSAGE_WRITER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_STATELESS_MESSAGE_READER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_STATELESS_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_WRITER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::BUILTIN_PARTICIPANT_VOLATILE_MESSAGE_SECURE_READER) {
     remote_id.entityId = ENTITYID_P2P_BUILTIN_PARTICIPANT_VOLATILE_SECURE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER) {
     remote_id.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_WRITER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (avail & DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_READER) {
     remote_id.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
     transport_inst_->update_locators(remote_id, remote_data);
   }
 
   const DDS::Security::ExtendedBuiltinEndpointSet_t& extended_avail =
     pdata.participantProxy.availableExtendedBuiltinEndpoints;
 
   if (extended_avail & DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_WRITER_SECURE) {
     remote_id.entityId = ENTITYID_TL_SVC_REQ_WRITER_SECURE;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (extended_avail & DDS::Security::TYPE_LOOKUP_SERVICE_REQUEST_READER_SECURE) {
     remote_id.entityId = ENTITYID_TL_SVC_REQ_READER_SECURE;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (extended_avail & DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_WRITER_SECURE) {
     remote_id.entityId = ENTITYID_TL_SVC_REPLY_WRITER_SECURE;
     transport_inst_->update_locators(remote_id, remote_data);
   }
   if (extended_avail & DDS::Security::TYPE_LOOKUP_SERVICE_REPLY_READER_SECURE) {
     remote_id.entityId = ENTITYID_TL_SVC_REPLY_READER_SECURE;
     transport_inst_->update_locators(remote_id, remote_data);
   }
 #endif
 }

◆ update_publication_locators()

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

Definition at line 6245 of file Sedp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, LM_INFO, local_publications_, OpenDDS::DCPS::TransportClient::lock_, and write_publication_data().

Referenced by ignoring().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   LocalPublicationIter iter = local_publications_.find(publicationId);
   if (iter != local_publications_.end()) {
     if (DCPS_debug_level > 3) {
       ACE_DEBUG((LM_INFO,
         ACE_TEXT("(%P|%t) Sedp::update_publication_locators: updating locators for %C\n"),
         LogGuid(publicationId).c_str()));
     }
     iter->second.trans_info_ = transInfo;
     write_publication_data(publicationId, iter->second);
   }
 }

◆ update_publication_qos()

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

Definition at line 1901 of file Sedp.cpp.

References ACE_GUARD_RETURN, local_publications_, lock_, match_endpoints(), OpenDDS::RTPS::LocalPublication::publisher_qos_, OpenDDS::RTPS::LocalPublication::qos_, DDS::RETCODE_OK, OpenDDS::RTPS::LocalEntity::topic_id_, topic_names_, topics_, and write_publication_data().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   LocalPublicationIter iter = local_publications_.find(publicationId);
   if (iter != local_publications_.end()) {
     LocalPublication& pb = iter->second;
     pb.qos_ = qos;
     pb.publisher_qos_ = publisherQos;
 
     if (DDS::RETCODE_OK != write_publication_data(publicationId, pb)) {
       return false;
     }
     // Match/unmatch with subscriptions
     String topic_name = topic_names_[pb.topic_id_];
     TopicDetailsMap::iterator top_it = topics_.find(topic_name);
     if (top_it != topics_.end()) {
       match_endpoints(publicationId, top_it->second);
     }
     return true;
   }
   return false;
 }

◆ update_subscription_locators()

void OpenDDS::RTPS::Sedp::update_subscription_locators	(	const GUID_t &	subscriptionId,
		const DCPS::TransportLocatorSeq &	transInfo
	)

Definition at line 6391 of file Sedp.cpp.

References ACE_DEBUG, ACE_GUARD, ACE_TEXT(), OpenDDS::DCPS::DCPS_debug_level, LM_INFO, local_subscriptions_, OpenDDS::DCPS::TransportClient::lock_, and write_subscription_data().

Referenced by ignoring().

 {
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
   LocalSubscriptionIter iter = local_subscriptions_.find(subscriptionId);
   if (iter != local_subscriptions_.end()) {
     if (DCPS_debug_level > 3) {
       ACE_DEBUG((LM_INFO,
         ACE_TEXT("(%P|%t) Sedp::update_subscription_locators: updating locators for %C\n"),
         LogGuid(subscriptionId).c_str()));
     }
     iter->second.trans_info_ = transInfo;
     write_subscription_data(subscriptionId, iter->second);
   }
 }

◆ update_subscription_params()

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

Definition at line 1977 of file Sedp.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::ContentFilterProperty_t::expressionParameters, OpenDDS::RTPS::LocalSubscription::filterProperties, local_publications_, local_subscriptions_, lock_, DDS::RETCODE_OK, and write_subscription_data().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   const LocalSubscriptionIter iter = local_subscriptions_.find(subId);
   if (iter != local_subscriptions_.end()) {
     LocalSubscription& sb = iter->second;
     sb.filterProperties.expressionParameters = params;
 
     if (DDS::RETCODE_OK != write_subscription_data(subId, sb)) {
       return false;
     }
 
     // Let any associated local publications know about the change
     for (DCPS::RepoIdSet::iterator i = iter->second.matched_endpoints_.begin();
          i != iter->second.matched_endpoints_.end(); ++i) {
       const LocalPublicationIter lpi = local_publications_.find(*i);
       if (lpi != local_publications_.end()) {
         DCPS::DataWriterCallbacks_rch pl = lpi->second.publication_.lock();
         if (pl) {
           pl->update_subscription_params(subId, params);
         }
       }
     }
 
     return true;
   }
   return false;
 }

◆ update_subscription_qos()

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

Definition at line 1951 of file Sedp.cpp.

References ACE_GUARD_RETURN, local_subscriptions_, lock_, match_endpoints(), OpenDDS::RTPS::LocalSubscription::qos_, DDS::RETCODE_OK, OpenDDS::RTPS::LocalSubscription::subscriber_qos_, OpenDDS::RTPS::LocalEntity::topic_id_, topic_names_, topics_, and write_subscription_data().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   LocalSubscriptionIter iter = local_subscriptions_.find(subscriptionId);
   if (iter != local_subscriptions_.end()) {
     LocalSubscription& sb = iter->second;
     sb.qos_ = qos;
     sb.subscriber_qos_ = subscriberQos;
 
     if (DDS::RETCODE_OK != write_subscription_data(subscriptionId, sb)) {
       return false;
     }
     // Match/unmatch with subscriptions
     String topic_name = topic_names_[sb.topic_id_];
     TopicDetailsMap::iterator top_it = topics_.find(topic_name);
     if (top_it != topics_.end()) {
       match_endpoints(subscriptionId, top_it->second);
     }
     return true;
   }
   return false;
 }

◆ update_topic_qos()

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

Definition at line 1840 of file Sedp.cpp.

References ACE_GUARD_RETURN, OpenDDS::DCPS::TopicDetails::local_publications(), local_publications_, OpenDDS::DCPS::TopicDetails::local_qos(), OpenDDS::DCPS::TopicDetails::local_subscriptions(), local_subscriptions_, lock_, name, OPENDDS_ASSERT, OPENDDS_MAP_CMP(), OPENDDS_STRING, DDS::TopicQos::topic_data, topic_names_, topics_, OpenDDS::DCPS::TopicDetails::update(), write_publication_data(), and write_subscription_data().

 {
   ACE_GUARD_RETURN(ACE_Thread_Mutex, g, lock_, false);
   OPENDDS_MAP_CMP(GUID_t, OPENDDS_STRING, DCPS::GUID_tKeyLessThan)::iterator iter =
     topic_names_.find(topicId);
   if (iter == topic_names_.end()) {
     return false;
   }
   const OPENDDS_STRING& name = iter->second;
   TopicDetails& topic = topics_[name];
   using namespace DCPS;
   // If the TOPIC_DATA QoS changed our local endpoints must be resent
   // with new QoS
   if (qos.topic_data != topic.local_qos().topic_data) {
     topic.update(qos);
     // For each endpoint associated on this topic
     for (RepoIdSet::const_iterator topic_endpoints = topic.local_publications().begin();
          topic_endpoints != topic.local_publications().end(); ++topic_endpoints) {
 
       const GUID_t& rid = *topic_endpoints;
       LocalPublicationIter lp = local_publications_.find(rid);
       OPENDDS_ASSERT(lp != local_publications_.end());
       write_publication_data(rid, lp->second);
     }
     for (RepoIdSet::const_iterator topic_endpoints = topic.local_subscriptions().begin();
          topic_endpoints != topic.local_subscriptions().end(); ++topic_endpoints) {
 
       const GUID_t& rid = *topic_endpoints;
       LocalSubscriptionIter ls = local_subscriptions_.find(rid);
       OPENDDS_ASSERT(ls != local_subscriptions_.end());
       write_subscription_data(rid, ls->second);
     }
   }
 
   return true;
 }

◆ use_ice_now()

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

Definition at line 5917 of file Sedp.cpp.

References ACE_GUARD, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, ice_agent_, OpenDDS::RTPS::LocalEntity::ice_agent_info, local_publications_, local_subscriptions_, OpenDDS::DCPS::WeakRcHandle< T >::lock(), OpenDDS::DCPS::TransportClient::lock_, OpenDDS::RTPS::LocalPublication::publication_, publication_agent_info_listener_, start_ice(), OpenDDS::RTPS::LocalSubscription::subscription_, subscription_agent_info_listener_, transport_inst_, and OpenDDS::DCPS::TransportInst::use_ice_now().

 {
   transport_inst_->use_ice_now(f);
 
 #ifdef OPENDDS_SECURITY
   if (!f) {
     return;
   }
 
   ACE_GUARD(ACE_Thread_Mutex, g, lock_);
 
   for (LocalPublicationIter pos = local_publications_.begin(), limit = local_publications_.end(); pos != limit; ++pos) {
     LocalPublication& pub = pos->second;
     DCPS::DataWriterCallbacks_rch pl = pub.publication_.lock();
     if (pl) {
       DCPS::WeakRcHandle<ICE::Endpoint> endpoint = pl->get_ice_endpoint();
       if (endpoint) {
         pub.have_ice_agent_info = true;
         pub.ice_agent_info = ice_agent_->get_local_agent_info(endpoint);
         ice_agent_->add_local_agent_info_listener(endpoint, pos->first, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(publication_agent_info_listener_));
         start_ice(pos->first, pub);
       }
     }
   }
   for (LocalSubscriptionIter pos = local_subscriptions_.begin(), limit = local_subscriptions_.end(); pos != limit; ++pos) {
     LocalSubscription& sub = pos->second;
     DCPS::DataReaderCallbacks_rch sl = sub.subscription_.lock();
     if (sl) {
       DCPS::WeakRcHandle<ICE::Endpoint> endpoint = sl->get_ice_endpoint();
       if (endpoint) {
         sub.have_ice_agent_info = true;
         sub.ice_agent_info = ice_agent_->get_local_agent_info(endpoint);
         ice_agent_->add_local_agent_info_listener(endpoint, pos->first, DCPS::static_rchandle_cast<ICE::AgentInfoListener>(subscription_agent_info_listener_));
         start_ice(pos->first, sub);
       }
     }
   }
 #endif
 }

◆ use_rtps_relay_now()

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

Definition at line 5911 of file Sedp.cpp.

References transport_inst_, and OpenDDS::DCPS::TransportInst::use_rtps_relay_now().

 {
   transport_inst_->use_rtps_relay_now(f);
 }

◆ write_dcps_participant_dispose()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_dcps_participant_dispose ( const DCPS::GUID_t & part )

Definition at line 4799 of file Sedp.cpp.

References dcps_participant_secure_writer_, and OpenDDS::RTPS::PID_PARTICIPANT_GUID.

 {
   return dcps_participant_secure_writer_->write_unregister_dispose(part, PID_PARTICIPANT_GUID);
 }

◆ write_dcps_participant_secure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_dcps_participant_secure	(	const Security::SPDPdiscoveredParticipantData &	msg,
		const DCPS::GUID_t &	part
	)

Definition at line 4787 of file Sedp.cpp.

References dcps_participant_secure_writer_, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::RTPS::ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER, OpenDDS::DCPS::GUID_UNKNOWN, and participant_secure_sequence_.

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

 {
   DCPS::GUID_t remote_reader(part);
   if (part != GUID_UNKNOWN) {
     remote_reader.entityId = ENTITYID_SPDP_RELIABLE_BUILTIN_PARTICIPANT_SECURE_READER;
   }
 
   return dcps_participant_secure_writer_->write_dcps_participant_secure(msg, remote_reader, participant_secure_sequence_);
 }

◆ write_durable_dcps_participant_secure()

void OpenDDS::RTPS::Sedp::write_durable_dcps_participant_secure ( const DCPS::GUID_t & reader )

Definition at line 4775 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::Spdp::build_local_pdata(), dcps_participant_secure_writer_, OpenDDS::Security::DPDK_SECURE, spdp_, DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER, and write_dcps_participant_secure().

Referenced by association_complete_i(), and replay_durable_data_for().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::SPDP_BUILTIN_PARTICIPANT_SECURE_WRITER)) {
     return;
   }
 
   write_dcps_participant_secure(
     spdp_.build_local_pdata(false, Security::DPDK_SECURE), reader);
   dcps_participant_secure_writer_->end_historic_samples(reader);
 }

◆ write_durable_participant_message_data()

void OpenDDS::RTPS::Sedp::write_durable_participant_message_data ( const DCPS::GUID_t & reader )

private

Definition at line 4713 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER, local_participant_automatic_liveliness_sn_, local_participant_manual_liveliness_sn_, OpenDDS::DCPS::make_id(), participant_id_, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE, participant_message_writer_, OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN(), spdp_, and write_participant_message_data().

Referenced by association_complete_i(), and replay_durable_data_for().

 {
   if (!(spdp_.available_builtin_endpoints() & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER)) {
     return;
   }
 
   if (local_participant_automatic_liveliness_sn_ != DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN()) {
     const GUID_t guid = make_id(participant_id_,
                                 PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE);
     write_participant_message_data(guid, local_participant_automatic_liveliness_sn_, reader);
   }
 
   if (local_participant_manual_liveliness_sn_ != DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN()) {
     const GUID_t guid = make_id(participant_id_,
                                 PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE);
     write_participant_message_data(guid, local_participant_manual_liveliness_sn_, reader);
   }
 
   participant_message_writer_->end_historic_samples(reader);
 }

◆ write_durable_participant_message_data_secure()

void OpenDDS::RTPS::Sedp::write_durable_participant_message_data_secure ( const DCPS::GUID_t & reader )

private

Definition at line 4736 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::available_builtin_endpoints(), DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER, local_participant_automatic_liveliness_sn_secure_, local_participant_manual_liveliness_sn_secure_, OpenDDS::DCPS::make_id(), participant_id_, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE, OpenDDS::RTPS::PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE, participant_message_secure_writer_, OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN(), spdp_, and write_participant_message_data_secure().

Referenced by association_complete_i(), and replay_durable_data_for().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER)) {
     return;
   }
 
   if (local_participant_automatic_liveliness_sn_secure_ != DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN()) {
     const GUID_t guid = make_id(participant_id_,
                                 PARTICIPANT_MESSAGE_DATA_KIND_AUTOMATIC_LIVELINESS_UPDATE);
     write_participant_message_data_secure(guid, local_participant_automatic_liveliness_sn_secure_, reader);
   }
 
   if (local_participant_manual_liveliness_sn_secure_ != DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN()) {
     const GUID_t guid = make_id(participant_id_,
                                 PARTICIPANT_MESSAGE_DATA_KIND_MANUAL_LIVELINESS_UPDATE);
     write_participant_message_data_secure(guid, local_participant_manual_liveliness_sn_secure_, reader);
   }
 
   participant_message_secure_writer_->end_historic_samples(reader);
 }

◆ write_durable_publication_data()

void OpenDDS::RTPS::Sedp::write_durable_publication_data	(	const DCPS::GUID_t &	reader,
		bool	secure
	)

private

Definition at line 4641 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER, local_publications_, publications_secure_writer_, publications_writer_, DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER, spdp_, write_publication_data(), and write_publication_data_secure().

Referenced by association_complete_i(), and replay_durable_data_for().

 {
   if (!(spdp_.available_builtin_endpoints() & (DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER
 #ifdef OPENDDS_SECURITY
                                                | DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER
 #endif
                                                ))) {
     return;
   }
 
   if (secure) {
 #ifdef OPENDDS_SECURITY
     LocalPublicationIter pub, end = local_publications_.end();
     for (pub = local_publications_.begin(); pub != end; ++pub) {
       if (pub->second.security_attribs_.base.is_discovery_protected) {
         write_publication_data_secure(pub->first, pub->second, reader);
       }
     }
     publications_secure_writer_->end_historic_samples(reader);
 #endif
   } else {
     LocalPublicationIter pub, end = local_publications_.end();
     for (pub = local_publications_.begin(); pub != end; ++pub) {
 #ifdef OPENDDS_SECURITY
       if (!pub->second.security_attribs_.base.is_discovery_protected) {
         write_publication_data(pub->first, pub->second, reader);
       }
 #else
       write_publication_data(pub->first, pub->second, reader);
 #endif
     }
     publications_writer_->end_historic_samples(reader);
   }
 }

◆ write_durable_subscription_data()

void OpenDDS::RTPS::Sedp::write_durable_subscription_data	(	const DCPS::GUID_t &	reader,
		bool	secure
	)

private

Definition at line 4677 of file Sedp.cpp.

References OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER, is_security_enabled(), local_subscriptions_, DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER, spdp_, subscriptions_secure_writer_, subscriptions_writer_, write_subscription_data(), and write_subscription_data_secure().

Referenced by association_complete_i(), and replay_durable_data_for().

 {
   if (!(spdp_.available_builtin_endpoints() & (DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER
 #ifdef OPENDDS_SECURITY
                                                | DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER
 #endif
                                                ))) {
     return;
   }
 
   if (secure) {
 #ifdef OPENDDS_SECURITY
     LocalSubscriptionIter sub, end = local_subscriptions_.end();
     for (sub = local_subscriptions_.begin(); sub != end; ++sub) {
       if (is_security_enabled() && sub->second.security_attribs_.base.is_discovery_protected) {
         write_subscription_data_secure(sub->first, sub->second, reader);
       }
     }
     subscriptions_secure_writer_->end_historic_samples(reader);
 #endif
   } else {
     LocalSubscriptionIter sub, end = local_subscriptions_.end();
     for (sub = local_subscriptions_.begin(); sub != end; ++sub) {
 #ifdef OPENDDS_SECURITY
       if (!(is_security_enabled() && sub->second.security_attribs_.base.is_discovery_protected)) {
         write_subscription_data(sub->first, sub->second, reader);
       }
 #else
       write_subscription_data(sub->first, sub->second, reader);
 #endif
     }
     subscriptions_writer_->end_historic_samples(reader);
   }
 }

◆ write_participant_message_data()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_participant_message_data	(	const DCPS::GUID_t &	rid,
		DCPS::SequenceNumber &	sn,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 5110 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::GUID_UNKNOWN, LM_INFO, notify_liveliness(), participant_message_writer_, OpenDDS::RTPS::ParticipantMessageData::participantGuid, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, and spdp_.

Referenced by signal_liveliness_unsecure(), and write_durable_participant_message_data().

 {
   if (!(spdp_.available_builtin_endpoints() & BUILTIN_ENDPOINT_PARTICIPANT_MESSAGE_DATA_WRITER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   //Update liveliness for local subscriptions
   ParticipantMessageData pmd;
   pmd.participantGuid = rid;
   notify_liveliness(pmd);
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
     result = participant_message_writer_->write_participant_message(pmd, reader, sn);
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_participant_message_data - ")
                ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_participant_message_data_secure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_participant_message_data_secure	(	const DCPS::GUID_t &	rid,
		DCPS::SequenceNumber &	sn,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 5135 of file Sedp.cpp.

References ACE_DEBUG, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER, OpenDDS::DCPS::DCPS_debug_level, OpenDDS::DCPS::GUID_UNKNOWN, LM_INFO, participant_message_secure_writer_, OpenDDS::RTPS::ParticipantMessageData::participantGuid, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, and spdp_.

Referenced by signal_liveliness_secure(), and write_durable_participant_message_data_secure().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::BUILTIN_PARTICIPANT_MESSAGE_SECURE_WRITER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
     ParticipantMessageData pmd;
     pmd.participantGuid = rid;
     result = participant_message_secure_writer_->write_participant_message(pmd, reader, sn);
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_participant_message_data_secure - ")
                ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_publication_data()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_publication_data	(	const DCPS::GUID_t &	rid,
		LocalPublication &	pub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 4830 of file Sedp.cpp.

References DDS::Security::EndpointSecurityAttributes::base, DDS::Security::TopicSecurityAttributes::is_discovery_protected, is_security_enabled(), DDS::RETCODE_OK, OpenDDS::RTPS::LocalEntity::security_attribs_, write_publication_data_secure(), and write_publication_data_unsecure().

Referenced by add_publication(), update_publication_locators(), update_publication_qos(), update_topic_qos(), and write_durable_publication_data().

 {
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled() && lp.security_attribs_.base.is_discovery_protected) {
     result = write_publication_data_secure(rid, lp, reader);
 
   } else {
 #endif
 
     result = write_publication_data_unsecure(rid, lp, reader);
 
 #ifdef OPENDDS_SECURITY
   }
 #endif
 
   return result;
 }

◆ write_publication_data_secure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_publication_data_secure	(	const DCPS::GUID_t &	rid,
		LocalPublication &	pub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 4904 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::data, OpenDDS::DCPS::DCPS_debug_level, DDS::Security::EndpointSecurityInfo::endpoint_security_attributes, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER, OpenDDS::DCPS::GUID_UNKNOWN, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, OpenDDS::RTPS::LocalEntity::ice_agent_info, LM_ERROR, LM_INFO, DDS::Security::EndpointSecurityAttributes::plugin_endpoint_attributes, DDS::Security::EndpointSecurityInfo::plugin_endpoint_security_attributes, populate_discovered_writer_msg(), publications_secure_writer_, DDS::RETCODE_ERROR, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, OpenDDS::RTPS::LocalEntity::security_attribs_, OpenDDS::RTPS::security_attributes_to_bitmask(), OpenDDS::RTPS::ParameterListConverter::DiscoveredPublication_SecurityWrapper::security_info, DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER, OpenDDS::RTPS::LocalEntity::sequence_, spdp_, OpenDDS::RTPS::ParameterListConverter::to_param_list(), OpenDDS::RTPS::LocalEntity::type_info_, and use_xtypes_.

Referenced by write_durable_publication_data(), and write_publication_data().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::SEDP_BUILTIN_PUBLICATIONS_SECURE_WRITER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
 
     ParameterListConverter::DiscoveredPublication_SecurityWrapper dwd;
     ParameterList plist;
     populate_discovered_writer_msg(dwd.data, rid, lp);
 
     dwd.security_info.endpoint_security_attributes = security_attributes_to_bitmask(lp.security_attribs_);
     dwd.security_info.plugin_endpoint_security_attributes = lp.security_attribs_.plugin_endpoint_attributes;
 
     // Convert to parameter list
     if (!ParameterListConverter::to_param_list(dwd, plist, use_xtypes_, lp.type_info_, false)) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::write_publication_data_secure - ")
                  ACE_TEXT("Failed to convert DiscoveredWriterData ")
                  ACE_TEXT("to ParameterList\n")));
       result = DDS::RETCODE_ERROR;
     }
     if (lp.have_ice_agent_info) {
       ICE::AgentInfoMap ai_map;
       ai_map["DATA"] = lp.ice_agent_info;
       if (!ParameterListConverter::to_param_list(ai_map, plist)) {
         ACE_ERROR((LM_ERROR,
                    ACE_TEXT("(%P|%t) ERROR: Sedp::write_publication_data_secure - ")
                    ACE_TEXT("Failed to convert ICE Agent info ")
                    ACE_TEXT("to ParameterList\n")));
         result = DDS::RETCODE_ERROR;
       }
     }
     if (DDS::RETCODE_OK == result) {
       GUID_t effective_reader = reader;
       if (reader != GUID_UNKNOWN)
         effective_reader.entityId = ENTITYID_SEDP_BUILTIN_PUBLICATIONS_SECURE_READER;
       result = publications_secure_writer_->write_parameter_list(plist, effective_reader, lp.sequence_);
     }
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_publication_data_secure - ")
                ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_publication_data_unsecure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_publication_data_unsecure	(	const DCPS::GUID_t &	rid,
		LocalPublication &	pub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 4854 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER, OpenDDS::DCPS::GUID_UNKNOWN, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, OpenDDS::RTPS::LocalEntity::ice_agent_info, LM_ERROR, LM_INFO, populate_discovered_writer_msg(), publications_writer_, DDS::RETCODE_ERROR, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, OpenDDS::RTPS::LocalEntity::sequence_, spdp_, OpenDDS::RTPS::ParameterListConverter::to_param_list(), OpenDDS::RTPS::LocalEntity::type_info_, and use_xtypes_.

Referenced by write_publication_data().

 {
   if (!(spdp_.available_builtin_endpoints() & DISC_BUILTIN_ENDPOINT_PUBLICATION_ANNOUNCER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
     DCPS::DiscoveredWriterData dwd;
     ParameterList plist;
     populate_discovered_writer_msg(dwd, rid, lp);
 
     // Convert to parameter list
     if (!ParameterListConverter::to_param_list(dwd, plist, use_xtypes_, lp.type_info_, false)) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::write_publication_data_unsecure - ")
                  ACE_TEXT("Failed to convert DiscoveredWriterData ")
                  ACE_TEXT(" to ParameterList\n")));
       result = DDS::RETCODE_ERROR;
     }
 #ifdef OPENDDS_SECURITY
     if (lp.have_ice_agent_info) {
       ICE::AgentInfoMap ai_map;
       ai_map["DATA"] = lp.ice_agent_info;
       if (!ParameterListConverter::to_param_list(ai_map, plist)) {
         ACE_ERROR((LM_ERROR,
                    ACE_TEXT("(%P|%t) ERROR: Sedp::write_publication_data_unsecure - ")
                    ACE_TEXT("Failed to convert ICE Agent info ")
                    ACE_TEXT("to ParameterList\n")));
         result = DDS::RETCODE_ERROR;
       }
     }
 #endif
 
     if (DDS::RETCODE_OK == result) {
       result = publications_writer_->write_parameter_list(plist, reader, lp.sequence_);
     }
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_publication_data_unsecure - ")
                ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_stateless_message()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_stateless_message	(	const DDS::Security::ParticipantStatelessMessage &	msg,
		const DCPS::GUID_t &	reader
	)

Definition at line 4758 of file Sedp.cpp.

References participant_stateless_message_writer_, and OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN().

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

 {
   DCPS::SequenceNumber sequence = DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN();
   return participant_stateless_message_writer_->write_stateless_message(msg, reader, sequence);
 }

◆ write_subscription_data()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_subscription_data	(	const DCPS::GUID_t &	rid,
		LocalSubscription &	sub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 4982 of file Sedp.cpp.

References DDS::Security::EndpointSecurityAttributes::base, DDS::Security::TopicSecurityAttributes::is_discovery_protected, is_security_enabled(), DDS::RETCODE_OK, OpenDDS::RTPS::LocalEntity::security_attribs_, write_subscription_data_secure(), and write_subscription_data_unsecure().

Referenced by add_subscription(), association_complete_i(), remove_assoc(), update_subscription_locators(), update_subscription_params(), update_subscription_qos(), update_topic_qos(), and write_durable_subscription_data().

 {
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
 
 #ifdef OPENDDS_SECURITY
   if (is_security_enabled() && ls.security_attribs_.base.is_discovery_protected) {
     result = write_subscription_data_secure(rid, ls, reader);
 
   } else {
 #endif
 
     result = write_subscription_data_unsecure(rid, ls, reader);
 
 #ifdef OPENDDS_SECURITY
   }
 #endif
 
   return result;
 }

◆ write_subscription_data_secure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_subscription_data_secure	(	const DCPS::GUID_t &	rid,
		LocalSubscription &	sub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 5056 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::data, OpenDDS::DCPS::DCPS_debug_level, DDS::Security::EndpointSecurityInfo::endpoint_security_attributes, OpenDDS::DCPS::GUID_t::entityId, OpenDDS::RTPS::ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER, OpenDDS::DCPS::GUID_UNKNOWN, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, OpenDDS::RTPS::LocalEntity::ice_agent_info, LM_ERROR, LM_INFO, DDS::Security::EndpointSecurityAttributes::plugin_endpoint_attributes, DDS::Security::EndpointSecurityInfo::plugin_endpoint_security_attributes, populate_discovered_reader_msg(), DDS::RETCODE_ERROR, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, OpenDDS::RTPS::LocalEntity::security_attribs_, OpenDDS::RTPS::security_attributes_to_bitmask(), OpenDDS::RTPS::ParameterListConverter::DiscoveredSubscription_SecurityWrapper::security_info, DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER, OpenDDS::RTPS::LocalEntity::sequence_, spdp_, subscriptions_secure_writer_, OpenDDS::RTPS::ParameterListConverter::to_param_list(), OpenDDS::RTPS::LocalEntity::type_info_, and use_xtypes_.

Referenced by write_durable_subscription_data(), and write_subscription_data().

 {
   if (!(spdp_.available_builtin_endpoints() & DDS::Security::SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_WRITER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
 
     ParameterListConverter::DiscoveredSubscription_SecurityWrapper drd;
     ParameterList plist;
     populate_discovered_reader_msg(drd.data, rid, ls);
 
     drd.security_info.endpoint_security_attributes = security_attributes_to_bitmask(ls.security_attribs_);
     drd.security_info.plugin_endpoint_security_attributes = ls.security_attribs_.plugin_endpoint_attributes;
 
     // Convert to parameter list
     if (!ParameterListConverter::to_param_list(drd, plist, use_xtypes_, ls.type_info_, false)) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::write_subscription_data_secure - ")
                  ACE_TEXT("Failed to convert DiscoveredReaderData ")
                  ACE_TEXT("to ParameterList\n")));
       result = DDS::RETCODE_ERROR;
     }
     if (ls.have_ice_agent_info) {
       ICE::AgentInfoMap ai_map;
       ai_map["DATA"] = ls.ice_agent_info;
       if (!ParameterListConverter::to_param_list(ai_map, plist)) {
         ACE_ERROR((LM_ERROR,
                    ACE_TEXT("(%P|%t) ERROR: Sedp::write_subscription_data_secure - ")
                    ACE_TEXT("Failed to convert ICE Agent info ")
                    ACE_TEXT("to ParameterList\n")));
         result = DDS::RETCODE_ERROR;
       }
     }
     if (DDS::RETCODE_OK == result) {
       GUID_t effective_reader = reader;
       if (reader != GUID_UNKNOWN)
         effective_reader.entityId = ENTITYID_SEDP_BUILTIN_SUBSCRIPTIONS_SECURE_READER;
       result = subscriptions_secure_writer_->write_parameter_list(plist, effective_reader, ls.sequence_);
     }
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_subscription_data_secure - ")
                         ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_subscription_data_unsecure()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_subscription_data_unsecure	(	const DCPS::GUID_t &	rid,
		LocalSubscription &	sub,
		const DCPS::GUID_t &	reader = `GUID_UNKNOWN`
	)

private

Definition at line 5006 of file Sedp.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT(), OpenDDS::RTPS::Spdp::associated(), associated_participants_, OpenDDS::RTPS::Spdp::available_builtin_endpoints(), OpenDDS::DCPS::DCPS_debug_level, OpenDDS::RTPS::DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER, OpenDDS::DCPS::GUID_UNKNOWN, OpenDDS::RTPS::LocalEntity::have_ice_agent_info, OpenDDS::RTPS::LocalEntity::ice_agent_info, LM_ERROR, LM_INFO, populate_discovered_reader_msg(), DDS::RETCODE_ERROR, DDS::RETCODE_OK, DDS::RETCODE_PRECONDITION_NOT_MET, OpenDDS::RTPS::LocalEntity::sequence_, spdp_, subscriptions_writer_, OpenDDS::RTPS::ParameterListConverter::to_param_list(), OpenDDS::RTPS::LocalEntity::type_info_, and use_xtypes_.

Referenced by write_subscription_data().

 {
   if (!(spdp_.available_builtin_endpoints() & DISC_BUILTIN_ENDPOINT_SUBSCRIPTION_ANNOUNCER)) {
     return DDS::RETCODE_PRECONDITION_NOT_MET;
   }
 
   DDS::ReturnCode_t result = DDS::RETCODE_OK;
   if (spdp_.associated() && (reader != GUID_UNKNOWN ||
                              !associated_participants_.empty())) {
     DCPS::DiscoveredReaderData drd;
     ParameterList plist;
     populate_discovered_reader_msg(drd, rid, ls);
 
     // Convert to parameter list
     if (!ParameterListConverter::to_param_list(drd, plist, use_xtypes_, ls.type_info_, false)) {
       ACE_ERROR((LM_ERROR,
                  ACE_TEXT("(%P|%t) ERROR: Sedp::write_subscription_data_unsecure - ")
                  ACE_TEXT("Failed to convert DiscoveredReaderData ")
                  ACE_TEXT("to ParameterList\n")));
       result = DDS::RETCODE_ERROR;
     }
 
 #ifdef OPENDDS_SECURITY
     if (ls.have_ice_agent_info) {
       ICE::AgentInfoMap ai_map;
       ai_map["DATA"] = ls.ice_agent_info;
       if (!ParameterListConverter::to_param_list(ai_map, plist)) {
         ACE_ERROR((LM_ERROR,
                    ACE_TEXT("(%P|%t) ERROR: Sedp::write_subscription_data_unsecure - ")
                    ACE_TEXT("Failed to convert ICE Agent info ")
                    ACE_TEXT("to ParameterList\n")));
         result = DDS::RETCODE_ERROR;
       }
     }
 #endif
     if (DDS::RETCODE_OK == result) {
       result = subscriptions_writer_->write_parameter_list(plist, reader, ls.sequence_);
     }
   } else if (DCPS::DCPS_debug_level > 3) {
     ACE_DEBUG((LM_INFO, ACE_TEXT("(%P|%t) Sedp::write_subscription_data_unsecure - ")
                ACE_TEXT("not currently associated, dropping msg.\n")));
   }
   return result;
 }

◆ write_volatile_message()

DDS::ReturnCode_t OpenDDS::RTPS::Sedp::write_volatile_message	(	DDS::Security::ParticipantVolatileMessageSecure &	msg,
		const DCPS::GUID_t &	reader
	)

Definition at line 4766 of file Sedp.cpp.

References DDS::Security::ParticipantGenericMessage::message_identity, participant_volatile_message_secure_writer_, DDS::Security::MessageIdentity::sequence_number, and OpenDDS::DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN().

Referenced by send_datareader_crypto_tokens(), and send_datawriter_crypto_tokens().

 {
   msg.message_identity.sequence_number = static_cast<unsigned long>(participant_volatile_message_secure_writer_->get_seq().getValue());
   DCPS::SequenceNumber sequence = DCPS::SequenceNumber::SEQUENCENUMBER_UNKNOWN();
   return participant_volatile_message_secure_writer_->write_volatile_message_secure(msg, reader, sequence);
 }