OpenDDS::ICE::Checklist Struct Reference

#include <Checklist.h>

Inheritance diagram for OpenDDS::ICE::Checklist:

Collaboration diagram for OpenDDS::ICE::Checklist:

Public Member Functions
	Checklist (EndpointManager *a_endpoint, const AgentInfo &a_local, const AgentInfo &a_remote, ACE_UINT64 a_ice_tie_breaker)
void	compute_active_foundations (ActiveFoundationSet &a_active_foundations) const
void	check_invariants () const
bool	has_transaction_id (const STUN::TransactionId &a_tid) const
bool	has_guid_pair (const GuidPair &a_guid_pair) const
void	unfreeze ()
void	unfreeze (const FoundationType &a_foundation)
void	generate_triggered_check (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, ACE_UINT32 a_priority, bool a_use_candidate)
void	success_response (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)
void	error_response (const ACE_INET_Addr &a_local_address, const ACE_INET_Addr &a_remote_address, const STUN::Message &a_message)
void	add_guid (const GuidPair &a_guid_pair)
void	remove_guid (const GuidPair &a_guid_pair)
void	add_guids (const GuidSetType &a_guids)
void	remove_guids ()
GuidSetType	guids () const
ACE_INET_Addr	selected_address () const
const AgentInfo &	original_remote_agent_info () const
void	set_remote_password (const std::string &a_password)
void	indication ()
Public Member Functions inherited from OpenDDS::ICE::Task
	Task (AgentImpl *a_agent_impl)
virtual	~Task ()
void	enqueue (const DCPS::MonotonicTimePoint &release_time)
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

Private Types
typedef std::list< CandidatePair >	CandidatePairsType
typedef std::list< ConnectivityCheck >	ConnectivityChecksType

Private Member Functions
	~Checklist ()
void	generate_candidate_pairs ()
void	fix_foundations ()
void	add_valid_pair (const CandidatePair &a_valid_pair)
bool	get_local_candidate (const ACE_INET_Addr &a_address, Candidate &a_candidate)
bool	get_remote_candidate (const ACE_INET_Addr &a_address, Candidate &a_candidate)
bool	is_succeeded (const CandidatePair &a_candidate_pair) const
bool	is_in_progress (const CandidatePair &a_candidate_pair) const
void	add_triggered_check (const CandidatePair &a_candidate_pair)
void	remove_from_in_progress (const CandidatePair &a_candidate_pair)
void	succeeded (const ConnectivityCheck &a_connectivity_check)
void	failed (const ConnectivityCheck &a_connectivity_check)
size_t	size () const
void	do_next_check (const DCPS::MonotonicTimePoint &a_now)
void	execute (const DCPS::MonotonicTimePoint &a_now)

Private Attributes
EndpointManager *const	endpoint_manager_
GuidSetType	guids_
AgentInfo	local_agent_info_
AgentInfo	remote_agent_info_
AgentInfo	original_remote_agent_info_
bool const	local_is_controlling_
ACE_UINT64 const	ice_tie_breaker_
CandidatePairsType	frozen_
CandidatePairsType	waiting_
CandidatePairsType	in_progress_
CandidatePairsType	succeeded_
CandidatePairsType	failed_
CandidatePairsType	triggered_check_queue_
CandidatePairsType	valid_list_
CandidatePairsType::const_iterator	nominating_
CandidatePairsType::const_iterator	nominated_
bool	nominated_is_live_
DCPS::MonotonicTimePoint	last_indication_
DCPS::TimeDuration	check_interval_
DCPS::TimeDuration	max_check_interval_
ConnectivityChecksType	connectivity_checks_

Additional Inherited Members
Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Detailed Description

Definition at line 155 of file Checklist.h.

Member Typedef Documentation

CandidatePairsType

typedef std::list<CandidatePair> OpenDDS::ICE::Checklist::CandidatePairsType

private

Definition at line 227 of file Checklist.h.

ConnectivityChecksType

typedef std::list<ConnectivityCheck> OpenDDS::ICE::Checklist::ConnectivityChecksType

private

Definition at line 244 of file Checklist.h.

Constructor & Destructor Documentation

Checklist()

OpenDDS::ICE::Checklist::Checklist	(	EndpointManager *	a_endpoint,
		const AgentInfo &	a_local,
		const AgentInfo &	a_remote,
		ACE_UINT64	a_ice_tie_breaker
	)

Definition at line 87 of file Checklist.cpp.

References endpoint_manager_, generate_candidate_pairs(), OpenDDS::DCPS::rchandle_from(), remote_agent_info_, OpenDDS::ICE::EndpointManager::set_responsible_checklist(), and OpenDDS::ICE::AgentInfo::username.

  : Task(a_endpoint_manager->agent_impl)
  , endpoint_manager_(a_endpoint_manager)
  , local_agent_info_(local)
  , remote_agent_info_(remote)
  , original_remote_agent_info_(remote)
  , local_is_controlling_(local.username < remote.username)
  , ice_tie_breaker_(a_ice_tie_breaker)
  , nominating_(valid_list_.end())
  , nominated_(valid_list_.end())
  , nominated_is_live_(false)
{
  endpoint_manager_->set_responsible_checklist(remote_agent_info_.username, rchandle_from(this));

  generate_candidate_pairs();
}

~Checklist()

OpenDDS::ICE::Checklist::~Checklist ( )

private

Definition at line 105 of file Checklist.cpp.

{
}

Member Function Documentation

add_guid()

void OpenDDS::ICE::Checklist::add_guid

(

const GuidPair &

a_guid_pair

)

Definition at line 757 of file Checklist.cpp.

References endpoint_manager_, guids_, OpenDDS::DCPS::rchandle_from(), and OpenDDS::ICE::EndpointManager::set_responsible_checklist().

Referenced by add_guids().

{
  guids_.insert(a_guid_pair);
  endpoint_manager_->set_responsible_checklist(a_guid_pair, rchandle_from(this));
}

add_guids()

void OpenDDS::ICE::Checklist::add_guids

(

const GuidSetType &

a_guids

)

Definition at line 782 of file Checklist.cpp.

References add_guid().

{
  for (GuidSetType::const_iterator pos = a_guids.begin(), limit = a_guids.end(); pos != limit; ++pos) {
    add_guid(*pos);
  }
}

add_triggered_check()

void OpenDDS::ICE::Checklist::add_triggered_check ( const CandidatePair &  a_candidate_pair )

private

Definition at line 269 of file Checklist.cpp.

References OpenDDS::ICE::AgentImpl::add(), OpenDDS::ICE::EndpointManager::agent_impl, endpoint_manager_, failed_, OpenDDS::ICE::CandidatePair::foundation, frozen_, in_progress_, nominated_, nominating_, OpenDDS::ICE::CandidatePair::priority_sorted(), succeeded_, triggered_check_queue_, valid_list_, and waiting_.

Referenced by execute(), and generate_triggered_check().

{
  if (nominating_ != valid_list_.end() || nominated_ != valid_list_.end()) {
    // Don't generate a check when we are done.
    return;
  }

  CandidatePairsType::iterator pos;

  pos = std::find(frozen_.begin(), frozen_.end(), a_candidate_pair);

  if (pos != frozen_.end()) {
    frozen_.erase(pos);
    endpoint_manager_->agent_impl->add(a_candidate_pair.foundation);
    waiting_.push_back(a_candidate_pair);
    waiting_.sort(CandidatePair::priority_sorted);
    triggered_check_queue_.push_back(a_candidate_pair);
    return;
  }

  pos = std::find(waiting_.begin(), waiting_.end(), a_candidate_pair);

  if (pos != waiting_.end()) {
    // Done.
    return;
  }

  pos = std::find(in_progress_.begin(), in_progress_.end(), a_candidate_pair);

  if (pos != in_progress_.end()) {
    // Duplicating to waiting.
    endpoint_manager_->agent_impl->add(a_candidate_pair.foundation);
    waiting_.push_back(a_candidate_pair);
    waiting_.sort(CandidatePair::priority_sorted);
    triggered_check_queue_.push_back(a_candidate_pair);
    return;
  }

  pos = std::find(succeeded_.begin(), succeeded_.end(), a_candidate_pair);

  if (pos != succeeded_.end()) {
    // Done.
    return;
  }

  pos = std::find(failed_.begin(), failed_.end(), a_candidate_pair);

  if (pos != failed_.end()) {
    failed_.erase(pos);
    endpoint_manager_->agent_impl->add(a_candidate_pair.foundation);
    waiting_.push_back(a_candidate_pair);
    waiting_.sort(CandidatePair::priority_sorted);
    triggered_check_queue_.push_back(a_candidate_pair);
    return;
  }

  // Not in checklist.
  endpoint_manager_->agent_impl->add(a_candidate_pair.foundation);
  waiting_.push_back(a_candidate_pair);
  waiting_.sort(CandidatePair::priority_sorted);
  triggered_check_queue_.push_back(a_candidate_pair);
}

add_valid_pair()

void OpenDDS::ICE::Checklist::add_valid_pair ( const CandidatePair &  a_valid_pair )

private

Definition at line 227 of file Checklist.cpp.

References OPENDDS_ASSERT, OpenDDS::ICE::CandidatePair::priority_sorted(), OpenDDS::ICE::CandidatePair::use_candidate, and valid_list_.

Referenced by success_response().

{
  OPENDDS_ASSERT(valid_pair.use_candidate);
  valid_list_.push_back(valid_pair);
  valid_list_.sort(CandidatePair::priority_sorted);
}

check_invariants()

void OpenDDS::ICE::Checklist::check_invariants

(

)

const

Definition at line 166 of file Checklist.cpp.

References OPENDDS_ASSERT, and valid_list_.

{
  for (CandidatePairsType::const_iterator pos = valid_list_.begin(), limit = valid_list_.end(); pos != limit; ++pos) {
    OPENDDS_ASSERT(pos->use_candidate);
  }
}

compute_active_foundations()

void OpenDDS::ICE::Checklist::compute_active_foundations

(

ActiveFoundationSet &

a_active_foundations

)

const

Definition at line 155 of file Checklist.cpp.

References OpenDDS::ICE::ActiveFoundationSet::add(), in_progress_, and waiting_.

{
  for (CandidatePairsType::const_iterator pos = waiting_.begin(), limit = waiting_.end(); pos != limit; ++pos) {
    active_foundations.add(pos->foundation);
  }

  for (CandidatePairsType::const_iterator pos = in_progress_.begin(), limit = in_progress_.end(); pos != limit; ++pos) {
    active_foundations.add(pos->foundation);
  }
}

do_next_check()

void OpenDDS::ICE::Checklist::do_next_check ( const DCPS::MonotonicTimePoint &  a_now )

private

Definition at line 627 of file Checklist.cpp.

References OpenDDS::ICE::Candidate::address, OpenDDS::ICE::ConnectivityCheck::cancelled(), OpenDDS::ICE::ConnectivityCheck::candidate_pair(), check_interval_, OpenDDS::ICE::Configuration::checklist_period(), connectivity_checks_, endpoint_manager_, OpenDDS::ICE::ConnectivityCheck::expiration_date(), failed(), ice_tie_breaker_, in_progress_, OpenDDS::ICE::Configuration::instance(), local_agent_info_, max_check_interval_, OpenDDS::ICE::AgentInfo::password, OpenDDS::ICE::ConnectivityCheck::password(), OpenDDS::ICE::CandidatePair::priority_sorted(), OpenDDS::DCPS::rchandle_from(), OpenDDS::ICE::CandidatePair::remote, remote_agent_info_, remove_from_in_progress(), OpenDDS::ICE::ConnectivityCheck::request(), OpenDDS::ICE::EndpointManager::send(), OpenDDS::ICE::EndpointManager::set_responsible_checklist(), OpenDDS::ICE::Configuration::T_a(), OpenDDS::STUN::Message::transaction_id, triggered_check_queue_, OpenDDS::ICE::EndpointManager::unset_responsible_checklist(), and waiting_.

Referenced by execute().

{
  // Triggered checks.
  if (!triggered_check_queue_.empty()) {
    CandidatePair cp = triggered_check_queue_.front();
    triggered_check_queue_.pop_front();

    ConnectivityCheck cc(cp, local_agent_info_, remote_agent_info_, ice_tie_breaker_, a_now + ICE::Configuration::instance()->connectivity_check_ttl());

    waiting_.remove(cp);
    in_progress_.push_back(cp);
    in_progress_.sort(CandidatePair::priority_sorted);

    endpoint_manager_->send(cc.candidate_pair().remote.address, cc.request());
    connectivity_checks_.push_back(cc);
    endpoint_manager_->set_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    check_interval_ = ICE::Configuration::instance()->T_a();
    return;
  }

  // Ordinary check.
  if (!waiting_.empty()) {
    CandidatePair cp = waiting_.front();
    waiting_.pop_front();

    ConnectivityCheck cc(cp, local_agent_info_, remote_agent_info_, ice_tie_breaker_, a_now + ICE::Configuration::instance()->connectivity_check_ttl());

    in_progress_.push_back(cp);
    in_progress_.sort(CandidatePair::priority_sorted);

    endpoint_manager_->send(cc.candidate_pair().remote.address, cc.request());
    connectivity_checks_.push_back(cc);
    endpoint_manager_->set_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    check_interval_ = ICE::Configuration::instance()->T_a();
    return;
  }

  // Retry.
  while (!connectivity_checks_.empty()) {
    ConnectivityCheck cc = connectivity_checks_.front();
    connectivity_checks_.pop_front();

    if (cc.expiration_date() < a_now) {
      if (!cc.cancelled()) {
        // Failing can allow nomination to proceed.
        failed(cc);
      } else {
        remove_from_in_progress(cc.candidate_pair());
      }

      endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
      continue;
    }

    // We leave the cancelled checks in case we get a response.
    if (!cc.cancelled()) {
      // Reset the password in the event that it changed.
      cc.password(remote_agent_info_.password);
      endpoint_manager_->send(cc.candidate_pair().remote.address, cc.request());
    }

    connectivity_checks_.push_back(cc);

    // Backoff.
    check_interval_ = std::min(check_interval_ * 2, max_check_interval_);
    break;
  }

  // Waiting for the remote or frozen.
  check_interval_ = ICE::Configuration::instance()->checklist_period();
}

error_response()

void OpenDDS::ICE::Checklist::error_response	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

Definition at line 560 of file Checklist.cpp.

References ACE_ERROR, ACE_TEXT(), OpenDDS::STUN::BAD_REQUEST, connectivity_checks_, endpoint_manager_, failed(), OpenDDS::STUN::Message::get_error_code(), OpenDDS::STUN::Message::get_error_reason(), OpenDDS::STUN::Message::get_unknown_attributes(), OpenDDS::STUN::Message::has_error_code(), OpenDDS::STUN::Message::has_fingerprint(), OpenDDS::STUN::Message::has_message_integrity(), OpenDDS::STUN::Message::has_unknown_attributes(), LM_WARNING, OPENDDS_ASSERT, OpenDDS::DCPS::rchandle_from(), OpenDDS::STUN::Message::transaction_id, OpenDDS::STUN::UNKNOWN_ATTRIBUTE, OpenDDS::STUN::Message::unknown_comprehension_required_attributes(), OpenDDS::ICE::EndpointManager::unset_responsible_checklist(), and OpenDDS::STUN::Message::verify_message_integrity().

{
  ConnectivityChecksType::iterator pos = std::find(connectivity_checks_.begin(), connectivity_checks_.end(), a_message.transaction_id);
  OPENDDS_ASSERT(pos != connectivity_checks_.end());

  ConnectivityCheck const cc = *pos;

  if (!a_message.has_message_integrity()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING No MESSAGE_INTEGRITY attribute\n")));
    // Retry.
    return;
  }

  if (!a_message.verify_message_integrity(cc.request().password)) {
    // Retry.
    return;
  }

  // We have a verified error response.
  std::vector<STUN::AttributeType> unknown_attributes = a_message.unknown_comprehension_required_attributes();

  if (!unknown_attributes.empty()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING Unknown comprehension required attributes\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  if (!a_message.has_fingerprint()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING No FINGERPRINT attribute\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  if (a_message.has_error_code()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING ")
      ACE_TEXT("STUN error response code=%d reason=%s\n"),
      a_message.get_error_code(),
      a_message.get_error_reason().c_str()));

    if (a_message.get_error_code() == STUN::UNKNOWN_ATTRIBUTE && a_message.has_unknown_attributes()) {
      std::vector<STUN::AttributeType> unknown_attributes = a_message.get_unknown_attributes();

      for (std::vector<STUN::AttributeType>::const_iterator pos = unknown_attributes.begin(),
           limit = unknown_attributes.end(); pos != limit; ++pos) {
        ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING Unknown STUN attribute %d\n"), *pos));
      }
    }

    if (a_message.get_error_code() == STUN::BAD_REQUEST || a_message.get_error_code() == STUN::UNKNOWN_ATTRIBUTE) {
      // Waiting and/or resending won't fix these errors.
      failed(cc);
      connectivity_checks_.erase(pos);
      endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    }
  }

  else {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::error_response: WARNING STUN error response (no code)\n")));
  }
}

execute()

void OpenDDS::ICE::Checklist::execute ( const DCPS::MonotonicTimePoint &  a_now )

privatevirtual

Implements OpenDDS::ICE::Task.

Definition at line 699 of file Checklist.cpp.

References add_triggered_check(), OpenDDS::STUN::Message::append_attribute(), OpenDDS::STUN::BINDING, check_interval_, OpenDDS::STUN::Message::class_, connectivity_checks_, do_next_check(), endpoint_manager_, OpenDDS::ICE::Task::enqueue(), frozen_, OpenDDS::STUN::Message::generate_transaction_id(), guids_, OpenDDS::ICE::EndpointManager::ice_connect(), OpenDDS::ICE::EndpointManager::ice_disconnect(), OpenDDS::STUN::INDICATION, OpenDDS::ICE::Configuration::instance(), last_indication_, local_agent_info_, local_is_controlling_, OpenDDS::STUN::make_fingerprint(), OpenDDS::STUN::make_message_integrity(), OpenDDS::STUN::make_username(), OpenDDS::STUN::Message::method, nominated_, nominated_is_live_, OpenDDS::ICE::Configuration::nominated_ttl(), nominating_, OpenDDS::ICE::AgentInfo::password, OpenDDS::STUN::Message::password, remote_agent_info_, OpenDDS::ICE::EndpointManager::send(), triggered_check_queue_, OpenDDS::ICE::AgentInfo::username, valid_list_, and waiting_.

{
  // Nominating check.
  if (frozen_.empty() &&
      waiting_.empty() &&
      // in_progress_.empty() &&
      local_is_controlling_ &&
      !valid_list_.empty() &&
      nominating_ == valid_list_.end() &&
      nominated_ == valid_list_.end()) {
    triggered_check_queue_.clear();
    add_triggered_check(valid_list_.front());
    nominating_ = valid_list_.begin();
  }

  bool flag = false;
  TimeDuration interval = std::max(check_interval_, ICE::Configuration::instance()->indication_period());

  if (!triggered_check_queue_.empty() ||
      !frozen_.empty() ||
      !waiting_.empty() ||
      !connectivity_checks_.empty()) {
    do_next_check(a_now);
    flag = true;
    interval = std::min(interval, check_interval_);
  }

  if (nominated_ != valid_list_.end()) {
    // Send an indication.
    STUN::Message message;
    message.class_ = STUN::INDICATION;
    message.method = STUN::BINDING;
    message.generate_transaction_id();
    message.append_attribute(STUN::make_username(remote_agent_info_.username + ":" + local_agent_info_.username));
    message.password = remote_agent_info_.password;
    message.append_attribute(STUN::make_message_integrity());
    message.append_attribute(STUN::make_fingerprint());
    endpoint_manager_->send(nominated_->remote.address, message);
    flag = true;
    interval = std::min(interval, ICE::Configuration::instance()->indication_period());

    // Check that we are receiving indications.
    const bool before = nominated_is_live_;
    nominated_is_live_ = (a_now - last_indication_) < ICE::Configuration::instance()->nominated_ttl();
    if (before && !nominated_is_live_) {
      endpoint_manager_->ice_disconnect(guids_, nominated_->remote.address);
    } else if (!before && nominated_is_live_) {
      endpoint_manager_->ice_connect(guids_, nominated_->remote.address);
    }
  }

  if (flag) {
    enqueue(MonotonicTimePoint::now() + interval);
  }

  // The checklist has failed.  Don't schedule.
}

failed()

void OpenDDS::ICE::Checklist::failed ( const ConnectivityCheck &  a_connectivity_check )

private

Definition at line 455 of file Checklist.cpp.

References OpenDDS::ICE::ConnectivityCheck::candidate_pair(), failed_, local_is_controlling_, nominating_, OpenDDS::ICE::CandidatePair::priority_sorted(), remove_from_in_progress(), OpenDDS::ICE::CandidatePair::use_candidate, and valid_list_.

Referenced by do_next_check(), error_response(), succeeded(), and success_response().

{
  const CandidatePair& cp = cc.candidate_pair();
  // 7.2.5.4
  remove_from_in_progress(cp);
  failed_.push_back(cp);
  failed_.sort(CandidatePair::priority_sorted);

  if (cp.use_candidate && local_is_controlling_) {
    valid_list_.pop_front();
    nominating_ = valid_list_.end();
  }
}

fix_foundations()

void OpenDDS::ICE::Checklist::fix_foundations ( )

private

Definition at line 234 of file Checklist.cpp.

References OpenDDS::ICE::EndpointManager::agent_impl, endpoint_manager_, in_progress_, OpenDDS::ICE::AgentImpl::remove(), and waiting_.

Referenced by remove_guid().

{
  for (CandidatePairsType::const_iterator pos = waiting_.begin(), limit = waiting_.end(); pos != limit; ++pos) {
    endpoint_manager_->agent_impl->remove(pos->foundation);
  }

  for (CandidatePairsType::const_iterator pos = in_progress_.begin(), limit = in_progress_.end(); pos != limit; ++pos) {
    endpoint_manager_->agent_impl->remove(pos->foundation);
  }
}

generate_candidate_pairs()

void OpenDDS::ICE::Checklist::generate_candidate_pairs ( )

private

Definition at line 109 of file Checklist.cpp.

References OpenDDS::ICE::AgentInfo::candidates, check_interval_, OpenDDS::ICE::Configuration::checklist_period(), frozen_, OpenDDS::ICE::Configuration::instance(), local_agent_info_, local_is_controlling_, max_check_interval_, OpenDDS::ICE::CandidatePair::priority_sorted(), remote_agent_info_, and OpenDDS::ICE::Configuration::T_a().

Referenced by Checklist().

{
  // Add the candidate pairs.
  AgentInfo::CandidatesType::const_iterator local_pos = local_agent_info_.candidates.begin();
  AgentInfo::CandidatesType::const_iterator local_limit = local_agent_info_.candidates.end();
  for (; local_pos != local_limit; ++local_pos) {
    AgentInfo::CandidatesType::const_iterator remote_pos = remote_agent_info_.candidates.begin();
    AgentInfo::CandidatesType::const_iterator remote_limit = remote_agent_info_.candidates.end();
    for (; remote_pos != remote_limit; ++remote_pos) {
#if ACE_HAS_IPV6
      if ((local_pos->address.is_linklocal() && remote_pos->address.is_linklocal()) ||
          (!local_pos->address.is_linklocal() && !remote_pos->address.is_linklocal())) {
        frozen_.push_back(CandidatePair(*local_pos, *remote_pos, local_is_controlling_));
      }
#else
      frozen_.push_back(CandidatePair(*local_pos, *remote_pos, local_is_controlling_));
#endif
    }
  }

  // Sort by priority.
  frozen_.sort(CandidatePair::priority_sorted);

  // Eliminate duplicates.
  for (CandidatePairsType::iterator pos = frozen_.begin(), limit = frozen_.end(); pos != limit; ++pos) {
    CandidatePairsType::iterator test_pos = pos;
    ++test_pos;

    while (test_pos != limit) {
      if (pos->local.base == test_pos->local.base && pos->remote == test_pos->remote) {
        frozen_.erase(test_pos++);
      }

      else {
        ++test_pos;
      }
    }
  }

  if (frozen_.size() != 0) {
    check_interval_ = ICE::Configuration::instance()->T_a();
    double s = static_cast<double>(frozen_.size());
    max_check_interval_ = ICE::Configuration::instance()->checklist_period() * (1.0 / s);
  }
}

generate_triggered_check()

void OpenDDS::ICE::Checklist::generate_triggered_check	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		ACE_UINT32	a_priority,
		bool	a_use_candidate
	)

Definition at line 340 of file Checklist.cpp.

References ACE_ERROR, ACE_TEXT(), add_triggered_check(), OpenDDS::ICE::EndpointManager::agent_impl, OpenDDS::ICE::AgentInfo::candidates, OpenDDS::ICE::candidates_sorted(), check_interval_, connectivity_checks_, endpoint_manager_, OpenDDS::ICE::Task::enqueue(), get_local_candidate(), get_remote_candidate(), OpenDDS::ICE::Configuration::instance(), is_in_progress(), is_succeeded(), LM_WARNING, local_is_controlling_, OpenDDS::ICE::make_peer_reflexive_candidate(), remote_agent_info_, OpenDDS::ICE::AgentImpl::remote_peer_reflexive_counter(), and OpenDDS::ICE::Configuration::T_a().

{
  Candidate remote;

  if (!get_remote_candidate(remote_address, remote)) {
    // 7.3.1.3
    remote = make_peer_reflexive_candidate(remote_address, priority, endpoint_manager_->agent_impl->remote_peer_reflexive_counter());
    remote_agent_info_.candidates.push_back(remote);
    std::sort(remote_agent_info_.candidates.begin(), remote_agent_info_.candidates.end(), candidates_sorted);
  }

  // 7.3.1.4
  Candidate local;
  bool flag = get_local_candidate(local_address, local);
  if (!flag) {
    // Network addresses may have changed so that local_address is not valid.
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::generate_triggered_check: WARNING local_address %C is no longer a local candidate\n"),
               DCPS::LogAddr(local_address).c_str()));
    return;
  }

  CandidatePair cp(local, remote, local_is_controlling_, use_candidate);

  if (is_succeeded(cp)) {
    return;
  }

  if (is_in_progress(cp)) {
    ConnectivityChecksType::iterator pos = std::find(connectivity_checks_.begin(), connectivity_checks_.end(), cp);
    pos->cancel();
  }

  add_triggered_check(cp);
  // This can move something from failed to in progress.
  // In that case, we need to schedule.
  check_interval_ = ICE::Configuration::instance()->T_a();
  enqueue(MonotonicTimePoint::now());
}

get_local_candidate()

bool OpenDDS::ICE::Checklist::get_local_candidate ( const ACE_INET_Addr &  a_address, Candidate &  a_candidate  )

private

Definition at line 245 of file Checklist.cpp.

References OpenDDS::ICE::AgentInfo::begin(), OpenDDS::ICE::AgentInfo::end(), and local_agent_info_.

Referenced by generate_triggered_check(), and success_response().

{
  for (AgentInfo::const_iterator pos = local_agent_info_.begin(), limit = local_agent_info_.end(); pos != limit; ++pos) {
    if (pos->address == address) {
      candidate = *pos;
      return true;
    }
  }

  return false;
}

get_remote_candidate()

bool OpenDDS::ICE::Checklist::get_remote_candidate ( const ACE_INET_Addr &  a_address, Candidate &  a_candidate  )

private

Definition at line 257 of file Checklist.cpp.

References OpenDDS::ICE::AgentInfo::begin(), OpenDDS::ICE::AgentInfo::end(), and remote_agent_info_.

Referenced by generate_triggered_check().

{
  for (AgentInfo::const_iterator pos = remote_agent_info_.begin(), limit = remote_agent_info_.end(); pos != limit; ++pos) {
    if (pos->address == address) {
      candidate = *pos;
      return true;
    }
  }

  return false;
}

guids()

GuidSetType OpenDDS::ICE::Checklist::guids ( ) const

inline

Definition at line 198 of file Checklist.h.

Referenced by remove_guids().

  {
    return guids_;
  }

has_guid_pair()

bool OpenDDS::ICE::Checklist::has_guid_pair ( const GuidPair &  a_guid_pair ) const

inline

Definition at line 169 of file Checklist.h.

  {
    return guids_.find(a_guid_pair) != guids_.end();
  }

has_transaction_id()

bool OpenDDS::ICE::Checklist::has_transaction_id ( const STUN::TransactionId &  a_tid ) const

inline

Definition at line 164 of file Checklist.h.

  {
    return std::find(connectivity_checks_.begin(), connectivity_checks_.end(), a_tid) != connectivity_checks_.end();
  }

indication()

void OpenDDS::ICE::Checklist::indication

(

)

Definition at line 807 of file Checklist.cpp.

References last_indication_, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::TimePoint_T< AceClock >::set_to_now().

{
  last_indication_.set_to_now();
}

is_in_progress()

bool OpenDDS::ICE::Checklist::is_in_progress ( const CandidatePair &  a_candidate_pair ) const

inlineprivate

Definition at line 264 of file Checklist.h.

Referenced by generate_triggered_check().

  {
    return std::find(in_progress_.begin(), in_progress_.end(), a_candidate_pair) != in_progress_.end();
  }

is_succeeded()

bool OpenDDS::ICE::Checklist::is_succeeded ( const CandidatePair &  a_candidate_pair ) const

inlineprivate

Definition at line 259 of file Checklist.h.

Referenced by generate_triggered_check().

  {
    return std::find(succeeded_.begin(), succeeded_.end(), a_candidate_pair) != succeeded_.end();
  }

original_remote_agent_info()

const AgentInfo& OpenDDS::ICE::Checklist::original_remote_agent_info ( ) const

inline

Definition at line 205 of file Checklist.h.

  {
    return original_remote_agent_info_;
  }

remove_from_in_progress()

void OpenDDS::ICE::Checklist::remove_from_in_progress ( const CandidatePair &  a_candidate_pair )

private

Definition at line 332 of file Checklist.cpp.

References OpenDDS::ICE::EndpointManager::agent_impl, endpoint_manager_, OpenDDS::ICE::CandidatePair::foundation, in_progress_, and OpenDDS::ICE::AgentImpl::remove().

Referenced by do_next_check(), failed(), and succeeded().

{
  endpoint_manager_->agent_impl->remove(a_candidate_pair.foundation);
  // Candidates can be in progress multiple times.
  CandidatePairsType::iterator pos = std::find(in_progress_.begin(), in_progress_.end(), a_candidate_pair);
  in_progress_.erase(pos);
}

remove_guid()

void OpenDDS::ICE::Checklist::remove_guid

(

const GuidPair &

a_guid_pair

)

Definition at line 763 of file Checklist.cpp.

References connectivity_checks_, endpoint_manager_, fix_foundations(), guids_, OpenDDS::DCPS::rchandle_from(), remote_agent_info_, OpenDDS::ICE::EndpointManager::unset_responsible_checklist(), and OpenDDS::ICE::AgentInfo::username.

Referenced by remove_guids().

{
  guids_.erase(a_guid_pair);
  endpoint_manager_->unset_responsible_checklist(a_guid_pair, rchandle_from(this));

  if (guids_.empty()) {
    // Cleanup this checklist.
    fix_foundations();

    for (ConnectivityChecksType::const_iterator pos = connectivity_checks_.begin(),
           limit = connectivity_checks_.end(); pos != limit; ++pos) {
      endpoint_manager_->unset_responsible_checklist(pos->request().transaction_id, rchandle_from(this));
    }

    // This should drop our ref-count to zero.
    endpoint_manager_->unset_responsible_checklist(remote_agent_info_.username, rchandle_from(this));
  }
}

remove_guids()

void OpenDDS::ICE::Checklist::remove_guids

(

)

Definition at line 789 of file Checklist.cpp.

References guids(), guids_, and remove_guid().

{
  GuidSetType guids = guids_;

  for (GuidSetType::const_iterator pos = guids.begin(), limit = guids.end(); pos != limit; ++pos) {
    remove_guid(*pos);
  }
}

selected_address()

ACE_INET_Addr OpenDDS::ICE::Checklist::selected_address

(

)

const

Definition at line 798 of file Checklist.cpp.

References nominated_, nominated_is_live_, and valid_list_.

{
  if (nominated_is_live_ && nominated_ != valid_list_.end()) {
    return nominated_->remote.address;
  }

  return ACE_INET_Addr();
}

set_remote_password()

void OpenDDS::ICE::Checklist::set_remote_password ( const std::string &  a_password )

inline

Definition at line 210 of file Checklist.h.

  {
    remote_agent_info_.password = a_password;
    original_remote_agent_info_.password = a_password;
  }

size()

size_t OpenDDS::ICE::Checklist::size ( void  ) const

inlineprivate

Definition at line 278 of file Checklist.h.

  {
    return frozen_.size() + waiting_.size() + in_progress_.size();
  }

succeeded()

void OpenDDS::ICE::Checklist::succeeded ( const ConnectivityCheck &  a_connectivity_check )

private

Definition at line 382 of file Checklist.cpp.

References OpenDDS::ICE::EndpointManager::agent_impl, OpenDDS::ICE::ConnectivityCheck::cancelled(), OpenDDS::ICE::ConnectivityCheck::candidate_pair(), connectivity_checks_, endpoint_manager_, failed(), failed_, OpenDDS::ICE::CandidatePair::foundation, frozen_, guids_, OpenDDS::ICE::EndpointManager::ice_connect(), in_progress_, last_indication_, local_is_controlling_, nominated_, nominated_is_live_, nominating_, OPENDDS_ASSERT, OpenDDS::ICE::CandidatePair::priority_sorted(), OpenDDS::DCPS::rchandle_from(), OpenDDS::ICE::AgentImpl::remove(), remove_from_in_progress(), OpenDDS::ICE::ConnectivityCheck::request(), OpenDDS::DCPS::TimePoint_T< AceClock >::set_to_now(), succeeded_, OpenDDS::STUN::Message::transaction_id, triggered_check_queue_, OpenDDS::ICE::AgentImpl::unfreeze(), OpenDDS::ICE::EndpointManager::unset_responsible_checklist(), OpenDDS::ICE::CandidatePair::use_candidate, valid_list_, and waiting_.

Referenced by success_response().

{
  const CandidatePair& cp = cc.candidate_pair();

  // 7.2.5.3.3
  // 7.2.5.4

  remove_from_in_progress(cp);
  succeeded_.push_back(cp);
  succeeded_.sort(CandidatePair::priority_sorted);

  if (cp.use_candidate) {
    if (local_is_controlling_) {
      nominated_ = nominating_;
      nominating_ = valid_list_.end();
      OPENDDS_ASSERT(frozen_.empty());
      OPENDDS_ASSERT(waiting_.empty());
    }

    else {
      nominated_ = std::find(valid_list_.begin(), valid_list_.end(), cp);

      // This is the case where the use_candidate check succeeded before the normal check.
      if (nominated_ == valid_list_.end()) {
        valid_list_.push_front(cp);
        nominated_ = valid_list_.begin();
      }

      while (!frozen_.empty()) {
        CandidatePair cp = frozen_.front();
        frozen_.pop_front();
        failed_.push_back(cp);
      }

      while (!waiting_.empty()) {
        CandidatePair cp = waiting_.front();
        waiting_.pop_front();
        endpoint_manager_->agent_impl->remove(cp.foundation);
        failed_.push_back(cp);
      }

      triggered_check_queue_.clear();
    }

    nominated_is_live_ = true;
    endpoint_manager_->ice_connect(guids_, nominated_->remote.address);
    last_indication_.set_to_now();

    while (!connectivity_checks_.empty()) {
      ConnectivityCheck cc = connectivity_checks_.front();
      connectivity_checks_.pop_front();

      if (!cc.cancelled()) {
        failed(cc);
      }

      else {
        remove_from_in_progress(cc.candidate_pair());
      }

      endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    }

    OPENDDS_ASSERT(frozen_.empty());
    OPENDDS_ASSERT(waiting_.empty());
    OPENDDS_ASSERT(triggered_check_queue_.empty());
    OPENDDS_ASSERT(in_progress_.empty());
    OPENDDS_ASSERT(connectivity_checks_.empty());
  }

  endpoint_manager_->agent_impl->unfreeze(cp.foundation);
}

success_response()

void OpenDDS::ICE::Checklist::success_response	(	const ACE_INET_Addr &	a_local_address,
		const ACE_INET_Addr &	a_remote_address,
		const STUN::Message &	a_message
	)

Definition at line 469 of file Checklist.cpp.

References ACE_ERROR, ACE_TEXT(), add_valid_pair(), OpenDDS::ICE::Candidate::address, OpenDDS::ICE::Candidate::base, OpenDDS::ICE::AgentInfo::candidates, OpenDDS::ICE::candidates_sorted(), connectivity_checks_, endpoint_manager_, failed(), get_local_candidate(), OpenDDS::STUN::Message::get_mapped_address(), OpenDDS::STUN::Message::has_fingerprint(), OpenDDS::STUN::Message::has_message_integrity(), LM_WARNING, OpenDDS::ICE::CandidatePair::local, local_agent_info_, local_is_controlling_, OpenDDS::ICE::make_peer_reflexive_candidate(), OPENDDS_ASSERT, OpenDDS::DCPS::rchandle_from(), OpenDDS::ICE::CandidatePair::remote, succeeded(), OpenDDS::STUN::Message::transaction_id, OpenDDS::STUN::Message::unknown_comprehension_required_attributes(), OpenDDS::ICE::EndpointManager::unset_responsible_checklist(), OpenDDS::ICE::CandidatePair::use_candidate, and OpenDDS::STUN::Message::verify_message_integrity().

{
  ConnectivityChecksType::iterator pos = std::find(connectivity_checks_.begin(), connectivity_checks_.end(), a_message.transaction_id);
  OPENDDS_ASSERT(pos != connectivity_checks_.end());

  ConnectivityCheck const cc = *pos;

  std::vector<STUN::AttributeType> unknown_attributes = a_message.unknown_comprehension_required_attributes();

  if (!unknown_attributes.empty()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::success_response: WARNING Unknown comprehension required attributes\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  if (!a_message.has_fingerprint()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::success_response: WARNING No FINGERPRINT attribute\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  ACE_INET_Addr mapped_address;

  if (!a_message.get_mapped_address(mapped_address)) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::success_response: WARNING No (XOR_)MAPPED_ADDRESS attribute\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  if (!a_message.has_message_integrity()) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::success_response: WARNING No MESSAGE_INTEGRITY attribute\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  // Require integrity for checks.
  if (!a_message.verify_message_integrity(cc.request().password)) {
    ACE_ERROR((LM_WARNING, ACE_TEXT("(%P|%t) Checklist::success_response: WARNING MESSAGE_INTEGRITY check failed\n")));
    failed(cc);
    connectivity_checks_.erase(pos);
    endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));
    return;
  }

  // At this point the check will either succeed or fail so remove from the list.
  connectivity_checks_.erase(pos);
  endpoint_manager_->unset_responsible_checklist(cc.request().transaction_id, rchandle_from(this));

  const CandidatePair& cp = cc.candidate_pair();

  if (remote_address != cp.remote.address || local_address != cp.local.base) {
    // 7.2.5.2.1 Non-Symmetric Transport Addresses
    failed(cc);
    return;
  }

  succeeded(cc);

  if (cp.use_candidate) {
    return;
  }

  // 7.2.5.3.2 Constructing a Valid Pair
  Candidate local;

  if (!get_local_candidate(mapped_address, local)) {
    // 7.2.5.3.1 Discovering Peer-Reflexive Candidates
    ACE_UINT32 priority;
    // Our message, no need to check.
    cc.request().get_priority(priority);
    local = make_peer_reflexive_candidate(mapped_address, cp.local.base, cp.remote.address, priority);
    local_agent_info_.candidates.push_back(local);
    std::sort(local_agent_info_.candidates.begin(), local_agent_info_.candidates.end(), candidates_sorted);
  }

  // The valid pair
  CandidatePair vp(local, cp.remote, local_is_controlling_, true);

  add_valid_pair(vp);
}

unfreeze() [1/2]

void OpenDDS::ICE::Checklist::unfreeze

(

)

Definition at line 173 of file Checklist.cpp.

References OpenDDS::ICE::AgentImpl::add(), OpenDDS::ICE::EndpointManager::agent_impl, OpenDDS::ICE::AgentImpl::contains(), endpoint_manager_, OpenDDS::ICE::Task::enqueue(), OpenDDS::ICE::CandidatePair::foundation, OpenDDS::ICE::EndpointManager::foundations(), frozen_, OpenDDS::ICE::CandidatePair::priority_sorted(), and waiting_.

{
  bool flag = false;

  for (CandidatePairsType::iterator pos = frozen_.begin(), limit = frozen_.end(); pos != limit;) {
    const CandidatePair& cp = *pos;

    // The second check allows the Checklist to start work on remote
    // foundations that also belong to its local agent meaning that the
    // remote agent is probably another EndpointManager in this
    // process.  They will share an AgentImpl and therefore the same
    // set of active foundations.  This will cause deadlock since both
    // cannot be the first to use the foundation unless we explicitly
    // allow it.
    if (!endpoint_manager_->agent_impl->contains(cp.foundation) ||
        endpoint_manager_->foundations().count(cp.foundation.second)) {
      endpoint_manager_->agent_impl->add(cp.foundation);
      waiting_.push_back(cp);
      waiting_.sort(CandidatePair::priority_sorted);
      frozen_.erase(pos++);
      flag = true;
    } else {
      ++pos;
    }
  }

  if (flag) {
    enqueue(MonotonicTimePoint::now());
  }
}

unfreeze() [2/2]

void OpenDDS::ICE::Checklist::unfreeze

(

const FoundationType &

a_foundation

)

Definition at line 204 of file Checklist.cpp.

References OpenDDS::ICE::AgentImpl::add(), OpenDDS::ICE::EndpointManager::agent_impl, endpoint_manager_, OpenDDS::ICE::Task::enqueue(), OpenDDS::ICE::CandidatePair::foundation, frozen_, OpenDDS::ICE::CandidatePair::priority_sorted(), and waiting_.

{
  bool flag = false;

  for (CandidatePairsType::iterator pos = frozen_.begin(), limit = frozen_.end(); pos != limit;) {
    const CandidatePair& cp = *pos;

    if (cp.foundation == a_foundation) {
      endpoint_manager_->agent_impl->add(cp.foundation);
      waiting_.push_back(cp);
      waiting_.sort(CandidatePair::priority_sorted);
      frozen_.erase(pos++);
      flag = true;
    } else {
      ++pos;
    }
  }

  if (flag) {
    enqueue(MonotonicTimePoint::now());
  }
}

Member Data Documentation

check_interval_

DCPS::TimeDuration OpenDDS::ICE::Checklist::check_interval_

private

Definition at line 242 of file Checklist.h.

Referenced by do_next_check(), execute(), generate_candidate_pairs(), and generate_triggered_check().

connectivity_checks_

ConnectivityChecksType OpenDDS::ICE::Checklist::connectivity_checks_

private

Definition at line 245 of file Checklist.h.

Referenced by do_next_check(), error_response(), execute(), generate_triggered_check(), remove_guid(), succeeded(), and success_response().

endpoint_manager_

EndpointManager* const OpenDDS::ICE::Checklist::endpoint_manager_

private

Definition at line 219 of file Checklist.h.

Referenced by add_guid(), add_triggered_check(), Checklist(), do_next_check(), error_response(), execute(), fix_foundations(), generate_triggered_check(), remove_from_in_progress(), remove_guid(), succeeded(), success_response(), and unfreeze().

failed_

CandidatePairsType OpenDDS::ICE::Checklist::failed_

private

Definition at line 232 of file Checklist.h.

Referenced by add_triggered_check(), failed(), and succeeded().

frozen_

CandidatePairsType OpenDDS::ICE::Checklist::frozen_

private

Definition at line 228 of file Checklist.h.

Referenced by add_triggered_check(), execute(), generate_candidate_pairs(), succeeded(), and unfreeze().

guids_

GuidSetType OpenDDS::ICE::Checklist::guids_

private

Definition at line 220 of file Checklist.h.

Referenced by add_guid(), execute(), remove_guid(), remove_guids(), and succeeded().

ice_tie_breaker_

ACE_UINT64 const OpenDDS::ICE::Checklist::ice_tie_breaker_

private

Definition at line 225 of file Checklist.h.

Referenced by do_next_check().

in_progress_

CandidatePairsType OpenDDS::ICE::Checklist::in_progress_

private

Definition at line 230 of file Checklist.h.

Referenced by add_triggered_check(), compute_active_foundations(), do_next_check(), fix_foundations(), remove_from_in_progress(), and succeeded().

last_indication_

DCPS::MonotonicTimePoint OpenDDS::ICE::Checklist::last_indication_

private

Definition at line 241 of file Checklist.h.

Referenced by execute(), indication(), and succeeded().

local_agent_info_

AgentInfo OpenDDS::ICE::Checklist::local_agent_info_

private

Definition at line 221 of file Checklist.h.

Referenced by do_next_check(), execute(), generate_candidate_pairs(), get_local_candidate(), and success_response().

local_is_controlling_

bool const OpenDDS::ICE::Checklist::local_is_controlling_

private

Definition at line 224 of file Checklist.h.

Referenced by execute(), failed(), generate_candidate_pairs(), generate_triggered_check(), succeeded(), and success_response().

max_check_interval_

DCPS::TimeDuration OpenDDS::ICE::Checklist::max_check_interval_

private

Definition at line 243 of file Checklist.h.

Referenced by do_next_check(), and generate_candidate_pairs().

nominated_

CandidatePairsType::const_iterator OpenDDS::ICE::Checklist::nominated_

private

Definition at line 239 of file Checklist.h.

Referenced by add_triggered_check(), execute(), selected_address(), and succeeded().

nominated_is_live_

bool OpenDDS::ICE::Checklist::nominated_is_live_

private

Definition at line 240 of file Checklist.h.

Referenced by execute(), selected_address(), and succeeded().

nominating_

CandidatePairsType::const_iterator OpenDDS::ICE::Checklist::nominating_

private

Definition at line 238 of file Checklist.h.

Referenced by add_triggered_check(), execute(), failed(), and succeeded().

original_remote_agent_info_

AgentInfo OpenDDS::ICE::Checklist::original_remote_agent_info_

private

Definition at line 223 of file Checklist.h.

remote_agent_info_

AgentInfo OpenDDS::ICE::Checklist::remote_agent_info_

private

Definition at line 222 of file Checklist.h.

Referenced by Checklist(), do_next_check(), execute(), generate_candidate_pairs(), generate_triggered_check(), get_remote_candidate(), and remove_guid().

succeeded_

CandidatePairsType OpenDDS::ICE::Checklist::succeeded_

private

Definition at line 231 of file Checklist.h.

Referenced by add_triggered_check(), and succeeded().

triggered_check_queue_

CandidatePairsType OpenDDS::ICE::Checklist::triggered_check_queue_

private

Definition at line 234 of file Checklist.h.

Referenced by add_triggered_check(), do_next_check(), execute(), and succeeded().

valid_list_

CandidatePairsType OpenDDS::ICE::Checklist::valid_list_

private

Definition at line 236 of file Checklist.h.

Referenced by add_triggered_check(), add_valid_pair(), check_invariants(), execute(), failed(), selected_address(), and succeeded().

waiting_

CandidatePairsType OpenDDS::ICE::Checklist::waiting_

private

Definition at line 229 of file Checklist.h.

Referenced by add_triggered_check(), compute_active_foundations(), do_next_check(), execute(), fix_foundations(), succeeded(), and unfreeze().

---

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

• Checklist.h
• Checklist.cpp