OpenDDS::Security::SecurityRegistry Class Reference

#include <SecurityRegistry.h>

Collaboration diagram for OpenDDS::Security::SecurityRegistry:

Classes
class	SecurityConfigEntry

Public Member Functions
void	release ()
SecurityPluginInst_rch	get_plugin_inst (const OPENDDS_STRING &plugin_name, bool attempt_fix=true)
void	register_plugin (const OPENDDS_STRING &plugin_name, SecurityPluginInst_rch plugin)
SecurityConfig_rch	create_config (const OPENDDS_STRING &config_name)
SecurityConfig_rch	create_config (const OPENDDS_STRING &config_name, SecurityPluginInst_rch plugin)
bool	has_no_configs () const
SecurityConfig_rch	get_config (const OPENDDS_STRING &config_name) const
SecurityConfig_rch	default_config () const
void	default_config (const SecurityConfig_rch &cfg)
SecurityConfig_rch	builtin_config () const
void	builtin_config (const SecurityConfig_rch &cfg)
int	load_security_configuration (ACE_Configuration_Heap &cf)

Static Public Member Functions
static SecurityRegistry *	instance ()
	Return a singleton instance of this class. More...
static void	close ()
	Close the singleton instance of this class. More...

Static Public Attributes
static const char *	DEFAULT_CONFIG_NAME = "_OPENDDS_DEFAULT_CONFIG"
static const char *	BUILTIN_CONFIG_NAME = "_OPENDDS_BUILTIN_CONFIG"

Private Types
typedef DCPS::RcHandle< SecurityConfigEntry >	SecurityConfigEntry_rch
typedef ACE_SYNCH_MUTEX	LockType
typedef ACE_Guard< LockType >	GuardType

Private Member Functions
typedef	OPENDDS_MAP (OPENDDS_STRING, SecurityConfig_rch) ConfigMap
typedef	OPENDDS_MAP (OPENDDS_STRING, SecurityPluginInst_rch) InstMap
typedef	OPENDDS_MAP (OPENDDS_STRING, OPENDDS_STRING) LibDirectiveMap
typedef	OPENDDS_MAP (OPENDDS_STRING, SecurityConfigEntry_rch) ConfigEntryMap
	SecurityRegistry ()
	~SecurityRegistry ()
int	load_security_sections (ACE_Configuration_Heap &cf, ConfigEntryMap &entries)
void	load_security_plugin_lib (const OPENDDS_STRING &security_plugin_type)
bool	find_config (const OPENDDS_STRING &name, SecurityConfig_rch &config)
bool	add_config (const OPENDDS_STRING &name, SecurityConfig_rch &config)

Private Attributes
ConfigEntryMap	config_entries_
ConfigMap	config_map_
InstMap	registered_plugins_
LibDirectiveMap	lib_directive_map_
SecurityConfig_rch	default_config_
SecurityConfig_rch	builtin_config_
LockType	lock_
LockType	default_load_lock_

Static Private Attributes
static const char *	DEFAULT_INST_PREFIX = "_OPENDDS_"
static const char *	DEFAULT_PLUGIN_NAME = "BuiltIn"
static const char *	SECURITY_SECTION_NAME = "security"
static const char *	ACCESS_CTRL_PLUGIN_NAME = "access_ctrl_plugin"
static const char *	AUTHENTICATION_PLUGIN_NAME = "auth_plugin"
static const char *	CRYPTO_PLUGIN_NAME = "crypto_plugin"

Friends
class	ACE_Singleton< SecurityRegistry, ACE_Recursive_Thread_Mutex >

Detailed Description

The TheSecurityRegistry is a singleton object which provides a mechanism to the application code to configure OpenDDS's security plugins.

Definition at line 34 of file SecurityRegistry.h.

Member Typedef Documentation

GuardType

typedef ACE_Guard<LockType> OpenDDS::Security::SecurityRegistry::GuardType

private

Definition at line 142 of file SecurityRegistry.h.

LockType

typedef ACE_SYNCH_MUTEX OpenDDS::Security::SecurityRegistry::LockType

private

Definition at line 141 of file SecurityRegistry.h.

SecurityConfigEntry_rch

typedef DCPS::RcHandle<SecurityConfigEntry> OpenDDS::Security::SecurityRegistry::SecurityConfigEntry_rch

private

Definition at line 123 of file SecurityRegistry.h.

Constructor & Destructor Documentation

SecurityRegistry()

OpenDDS::Security::SecurityRegistry::SecurityRegistry ( )

private

Definition at line 94 of file SecurityRegistry.cpp.

References DBG_ENTRY_LVL, DEFAULT_PLUGIN_NAME, and lib_directive_map_.

{
  DBG_ENTRY_LVL("SecurityRegistry", "SecurityRegistry", 6);
  lib_directive_map_[DEFAULT_PLUGIN_NAME] = "dynamic OpenDDS_Security Service_Object * OpenDDS_Security:_make_BuiltInPluginLoader()";
}

~SecurityRegistry()

OpenDDS::Security::SecurityRegistry::~SecurityRegistry ( )

private

Definition at line 49 of file SecurityRegistry.cpp.

References DBG_ENTRY_LVL, and release().

{
  DBG_ENTRY_LVL("SecurityRegistry", "~SecurityRegistry", 6);
  release();
}

Member Function Documentation

add_config()

bool OpenDDS::Security::SecurityRegistry::add_config ( const OPENDDS_STRING &  name, SecurityConfig_rch &  config  )

private

Definition at line 403 of file SecurityRegistry.cpp.

References config_map_, lock_, and name.

Referenced by create_config().

{
  GuardType guard(lock_);

  bool added_config = false;
  ConfigMap::iterator iConfig = config_map_.find(name);
  if (iConfig == config_map_.end()) {
    config_map_[name] = config;
    added_config = true;
  } else {
    // Someone else added this already. Use it instead
    config = iConfig->second;
    added_config = true;
  }

  return added_config;
}

builtin_config() [1/2]

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::builtin_config

(

)

const

Definition at line 278 of file SecurityRegistry.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, ACE_Guard< ACE_LOCK >::acquire(), builtin_config_, default_load_lock_, DEFAULT_PLUGIN_NAME, lib_directive_map_, lock_, OPENDDS_ASSERT, ACE_Service_Config::process_directive(), and ACE_Guard< ACE_LOCK >::release().

{
#if defined(OPENDDS_SECURITY)
  GuardType g1(default_load_lock_);
  GuardType guard(lock_);
  if (!builtin_config_) {
#if !defined(ACE_AS_STATIC_LIBS)
    LibDirectiveMap::const_iterator lib_iter = lib_directive_map_.find(DEFAULT_PLUGIN_NAME);
    OPENDDS_ASSERT(lib_iter != lib_directive_map_.end());
    ACE_TString directive = ACE_TEXT_CHAR_TO_TCHAR(lib_iter->second.c_str());
    guard.release();
    ACE_Service_Config::process_directive(directive.c_str());
    guard.acquire();
#endif
  }
#endif
  return builtin_config_;
}

builtin_config() [2/2]

void OpenDDS::Security::SecurityRegistry::builtin_config

(

const SecurityConfig_rch &

cfg

)

Definition at line 298 of file SecurityRegistry.cpp.

References builtin_config_, and lock_.

{
  GuardType guard(lock_);
  builtin_config_ = config;
}

close()

void OpenDDS::Security::SecurityRegistry::close ( void  )

static

Close the singleton instance of this class.

Definition at line 89 of file SecurityRegistry.cpp.

References ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::close().

Referenced by OpenDDS::DCPS::Service_Participant::shutdown().

{
  ACE_Unmanaged_Singleton<SecurityRegistry, ACE_Recursive_Thread_Mutex>::close();
}

create_config() [1/2]

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::create_config

(

const OPENDDS_STRING &

config_name

)

Definition at line 130 of file SecurityRegistry.cpp.

References ACE_ERROR, ACE_TEXT(), add_config(), config_entries_, find_config(), get_plugin_inst(), OpenDDS::DCPS::RcHandle< T >::is_nil(), and LM_ERROR.

{
  // If the configuration instance already exists, then it can be reused.
  // Otherwise create a new one and save it for any later needs
  SecurityConfig_rch existing_config;
  if (find_config(config_name, existing_config)) {
    return existing_config;
  }

  // This is making an assumption that the entry map is only written
  // to in single-threaded operation, and all acess from that point on
  // is read-only
  ConfigEntryMap::const_iterator iEntry = config_entries_.find(config_name);
  if (iEntry == config_entries_.end()) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("config=%C does not exist.\n"),
               config_name.c_str()));
    return SecurityConfig_rch();
  }

  // This will load any libraries that need to be loaded, and use the
  // resulting plugin instance objects to create the concrete implementations
  const SecurityConfigEntry_rch& entry = iEntry->second;
  SecurityPluginInst_rch auth_plugin_inst = get_plugin_inst(entry->get_auth_name());
  if (auth_plugin_inst.is_nil()) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("Failed to load authentication plugin %C\n"),
               entry->get_auth_name().c_str()));
    return SecurityConfig_rch();
  }

  SecurityPluginInst_rch ac_plugin_inst = get_plugin_inst(entry->get_access_control_name());
  if (ac_plugin_inst.is_nil()) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("Failed to load access control plugin %C\n"),
               entry->get_access_control_name().c_str()));
    return SecurityConfig_rch();
  }

  SecurityPluginInst_rch crypto_plugin_inst = get_plugin_inst(entry->get_crypto_name());
  if (crypto_plugin_inst.is_nil()) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("Failed to load crypto plugin %C\n"),
               entry->get_crypto_name().c_str()));
    return SecurityConfig_rch();
  }

  // Create the new config and try to add it to the container
  // of existing configs.  If this fails for some reason, then
  // release the new config and fail
  SecurityConfig_rch new_config =
    DCPS::make_rch<SecurityConfig>(config_name,
#ifdef OPENDDS_SECURITY
                                   auth_plugin_inst->create_authentication(),
                                   ac_plugin_inst->create_access_control(),
                                   crypto_plugin_inst->create_crypto_key_exchange(),
                                   crypto_plugin_inst->create_crypto_key_factory(),
                                   crypto_plugin_inst->create_crypto_transform(),
                                   DCPS::RcHandle<Utility>(),
#endif
                                   entry->get_properties());

  if (!add_config(config_name, new_config)) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("Error storing config instance %C\n"),
               config_name.c_str()));
    return SecurityConfig_rch();
  }

  return new_config;
}

create_config() [2/2]

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::create_config	(	const OPENDDS_STRING &	config_name,
		SecurityPluginInst_rch	plugin
	)

Definition at line 208 of file SecurityRegistry.cpp.

References ACE_ERROR, ACE_TEXT(), add_config(), find_config(), and LM_ERROR.

{
#ifndef OPENDDS_SECURITY
  ACE_UNUSED_ARG(plugin);
#endif

  SecurityConfig_rch existing_config;
  if (find_config(config_name, existing_config)) {
    return existing_config;
  }

  SecurityConfig_rch new_config =
    DCPS::make_rch<SecurityConfig>(config_name,
#ifdef OPENDDS_SECURITY
                                   plugin->create_authentication(),
                                   plugin->create_access_control(),
                                   plugin->create_crypto_key_exchange(),
                                   plugin->create_crypto_key_factory(),
                                   plugin->create_crypto_transform(),
                                   plugin->create_utility(),
#endif
                                   ConfigPropertyList());

  if (!add_config(config_name, new_config)) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::create_config: ")
               ACE_TEXT("Error storing config instance %C\n"),
               config_name.c_str()));
    return SecurityConfig_rch();
  }

  return new_config;
}

default_config() [1/2]

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::default_config

(

)

const

Definition at line 252 of file SecurityRegistry.cpp.

References default_config_, lock_, and TheServiceParticipant.

{
#if defined(OPENDDS_SECURITY)
  GuardType guard(lock_);
  if (!default_config_ && !TheServiceParticipant->get_security()) {
    Authentication_var a;
    AccessControl_var b;
    CryptoKeyExchange_var c;
    CryptoKeyFactory_var d;
    CryptoTransform_var e;
    default_config_ = DCPS::make_rch<SecurityConfig>("NoPlugins", a, b, c, d, e,
                                                     DCPS::RcHandle<Utility>(),
                                                     ConfigPropertyList());
  }
#endif
  return default_config_;
}

default_config() [2/2]

void OpenDDS::Security::SecurityRegistry::default_config

(

const SecurityConfig_rch &

cfg

)

Definition at line 271 of file SecurityRegistry.cpp.

References default_config_, and lock_.

{
  GuardType guard(lock_);
  default_config_ = config;
}

find_config()

bool OpenDDS::Security::SecurityRegistry::find_config ( const OPENDDS_STRING &  name, SecurityConfig_rch &  config  )

private

Definition at line 388 of file SecurityRegistry.cpp.

References config_map_, and lock_.

Referenced by create_config().

{
  GuardType guard(lock_);

  bool found_config = false;
  ConfigMap::iterator iConfig = config_map_.find(name);
  if (iConfig != config_map_.end()) {
    config = iConfig->second;
    found_config = true;
  }

  return found_config;
}

get_config()

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::get_config

(

const OPENDDS_STRING &

config_name

)

const

Definition at line 244 of file SecurityRegistry.cpp.

References config_map_, and lock_.

{
  GuardType guard(lock_);
  ConfigMap::const_iterator found = config_map_.find(config_name);
  return found == config_map_.end() ? SecurityConfig_rch() : found->second;
}

get_plugin_inst()

SecurityPluginInst_rch OpenDDS::Security::SecurityRegistry::get_plugin_inst	(	const OPENDDS_STRING &	plugin_name,
		bool	attempt_fix = true
	)

If the plugin is registered then return it. If it's not and attempt_fix is true, then try to load and return the plugin, otherwise return a nil rch.

Definition at line 421 of file SecurityRegistry.cpp.

References ACE_Guard< ACE_LOCK >::acquire(), find(), load_security_plugin_lib(), lock_, registered_plugins_, and ACE_Guard< ACE_LOCK >::release().

Referenced by create_config().

{
  GuardType guard(lock_);

  SecurityPluginInst_rch plugin_inst;

  if (find(registered_plugins_, plugin_name, plugin_inst) != 0 && attempt_fix) {
#if !defined(ACE_AS_STATIC_LIBS)
    guard.release();
    // Not present, try to load library
    load_security_plugin_lib(plugin_name);
    guard.acquire();

    // Try to find it again
    find(registered_plugins_, plugin_name, plugin_inst);
#endif
  }

  return plugin_inst;
}

has_no_configs()

bool OpenDDS::Security::SecurityRegistry::has_no_configs

(

)

const

Definition at line 443 of file SecurityRegistry.cpp.

References config_map_, lock_, and OPENDDS_END_VERSIONED_NAMESPACE_DECL.

{
  GuardType guard(lock_);
  return config_map_.empty();
}

instance()

SecurityRegistry * OpenDDS::Security::SecurityRegistry::instance ( void  )

static

Return a singleton instance of this class.

Definition at line 83 of file SecurityRegistry.cpp.

References ACE_Unmanaged_Singleton< TYPE, ACE_LOCK >::instance().

{
  return ACE_Unmanaged_Singleton<SecurityRegistry, ACE_Recursive_Thread_Mutex>::instance();
}

load_security_configuration()

int OpenDDS::Security::SecurityRegistry::load_security_configuration

(

ACE_Configuration_Heap &

cf

)

For internal use by OpenDDS DCPS layer: Transfer the configuration in ACE_Configuration_Heap object to the SecurityRegistry. This is called by the Service_Participant at initialization time. This function iterates each section in the configuration file, and creates SecurityConfigEntry objects and adds them to the registry.

Definition at line 305 of file SecurityRegistry.cpp.

References ACE_ERROR_RETURN, ACE_TEXT(), ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< char >::c_str(), config_entries_, ACE_Configuration_Heap::enumerate_sections(), LM_ERROR, ACE_Configuration_Heap::open_section(), OPENDDS_STRING, OpenDDS::DCPS::processSections(), OpenDDS::DCPS::pullValues(), ACE_Configuration::root_section(), SECURITY_SECTION_NAME, and ACE_OS::strcmp().

{
  const ACE_Configuration_Section_Key& root = cf.root_section();
  ACE_TString sect_name;

  for (int index = 0; cf.enumerate_sections(root, index, sect_name) == 0; ++index) {
    if (ACE_OS::strcmp(sect_name.c_str(), ACE_TEXT_CHAR_TO_TCHAR(SECURITY_SECTION_NAME)) == 0) {
      // found the section, now iterate through subsections...
      ACE_Configuration_Section_Key sect;
      if (cf.open_section(root, sect_name.c_str(), false, sect) != 0) {
        ACE_ERROR_RETURN((LM_ERROR,
                          ACE_TEXT("(%P|%t) SecurityRegistry::load_plugin_properties: ")
                          ACE_TEXT("failed to open section %s\n"),
                          sect_name.c_str()),
                         -1);
      }

      // Ensure there are no properties in this section
      DCPS::ValueMap vm;
      if (DCPS::pullValues(cf, sect, vm) > 0) {
        // There are values inside [transport]
        ACE_ERROR_RETURN((LM_ERROR,
                          ACE_TEXT("(%P|%t) SecurityRegistry::load_plugin_properties: ")
                          ACE_TEXT("[%s] sections must have a section name\n"),
                          sect_name.c_str()),
                         -1);
      }
      // Process the subsections of this section
      DCPS::KeyList keys;
      if (DCPS::processSections(cf, sect, keys) != 0) {
        ACE_ERROR_RETURN((LM_ERROR,
                          ACE_TEXT("(%P|%t) SecurityRegistry::load_plugin_properties: ")
                          ACE_TEXT("too many nesting layers in [%s] section.\n"),
                          sect_name.c_str()),
                         -1);
      }

      // Save the properties configured for each security entry
      for (DCPS::KeyList::const_iterator it = keys.begin(); it != keys.end(); ++it) {
        const OPENDDS_STRING& entry_name = it->first;
        // Duplicate entry check
        if (config_entries_.find(entry_name) != config_entries_.end()) {
          ACE_ERROR_RETURN((LM_ERROR,
                            ACE_TEXT("(%P|%t) SecurityRegistry::load_plugin_properties: ")
                            ACE_TEXT("duplicate sections named [%s/%C].\n"),
                            sect_name.c_str(), entry_name.c_str()),
                           -1);
        }

        // Copy any existing properties in the entry and create the SecurityConfigEntry, which
        // will be stored until actual plugin instances are needed for this configuration
        SecurityConfigEntry_rch newEntry =
          DCPS::make_rch<SecurityConfigEntry>(it->first);
        DCPS::ValueMap values;
        DCPS::pullValues(cf, it->second, values);
        for (DCPS::ValueMap::const_iterator val = values.begin(); val != values.end(); ++val) {
          newEntry->add_property(val->first, val->second);
        }

        config_entries_[it->first] = newEntry;
      }
    }
  }

  return 0;
}

load_security_plugin_lib()

void OpenDDS::Security::SecurityRegistry::load_security_plugin_lib ( const OPENDDS_STRING &  security_plugin_type )

private

For internal use by OpenDDS DCPS layer: Dynamically load the library for the supplied security plugin type.

Definition at line 373 of file SecurityRegistry.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< char >::c_str(), lib_directive_map_, lock_, ACE_Service_Config::process_directive(), and ACE_Guard< ACE_LOCK >::release().

Referenced by get_plugin_inst().

{
  ACE_UNUSED_ARG(security_plugin_type);
#if !defined(ACE_AS_STATIC_LIBS)
  GuardType guard(lock_);
  LibDirectiveMap::iterator lib_iter = lib_directive_map_.find(security_plugin_type);
  if (lib_iter != lib_directive_map_.end()) {
    ACE_TString directive = ACE_TEXT_CHAR_TO_TCHAR(lib_iter->second.c_str());
    guard.release();
    ACE_Service_Config::process_directive(directive.c_str());
  }
#endif
}

load_security_sections()

int OpenDDS::Security::SecurityRegistry::load_security_sections ( ACE_Configuration_Heap &  cf, ConfigEntryMap &  entries  )

private

OPENDDS_MAP() [1/4]

typedef OpenDDS::Security::SecurityRegistry::OPENDDS_MAP ( OPENDDS_STRING  , SecurityConfig_rch    )

private

OPENDDS_MAP() [2/4]

typedef OpenDDS::Security::SecurityRegistry::OPENDDS_MAP ( OPENDDS_STRING  , SecurityPluginInst_rch    )

private

OPENDDS_MAP() [3/4]

typedef OpenDDS::Security::SecurityRegistry::OPENDDS_MAP ( OPENDDS_STRING  , OPENDDS_STRING    )

private

OPENDDS_MAP() [4/4]

typedef OpenDDS::Security::SecurityRegistry::OPENDDS_MAP ( OPENDDS_STRING  , SecurityConfigEntry_rch    )

private

register_plugin()

void OpenDDS::Security::SecurityRegistry::register_plugin	(	const OPENDDS_STRING &	plugin_name,
		SecurityPluginInst_rch	plugin
	)

Definition at line 114 of file SecurityRegistry.cpp.

References ACE_ERROR, ACE_TEXT(), LM_ERROR, lock_, and registered_plugins_.

{
  GuardType guard(lock_);

  if (registered_plugins_.find(plugin_name) != registered_plugins_.end()) {
    ACE_ERROR((LM_ERROR,
               ACE_TEXT("(%P|%t) SecurityRegistry::register_plugin: ")
               ACE_TEXT("plugin=%C already exists.\n"),
               plugin_name.c_str()));
  } else {
    registered_plugins_.insert(std::make_pair(plugin_name, plugin));
  }
}

release()

void OpenDDS::Security::SecurityRegistry::release

(

void

)

This will shutdown all Security plugin objects.

Client Application calls this method to tear down the security framework.

Definition at line 101 of file SecurityRegistry.cpp.

References config_map_, DBG_ENTRY_LVL, lock_, and registered_plugins_.

Referenced by ~SecurityRegistry().

{
  DBG_ENTRY_LVL("SecurityRegistry", "release", 6);
  GuardType guard(lock_);

  for (InstMap::iterator iter = registered_plugins_.begin(); iter != registered_plugins_.end(); ++iter) {
    iter->second->shutdown();
  }
  registered_plugins_.clear();
  config_map_.clear();
}

Friends And Related Function Documentation

ACE_Singleton< SecurityRegistry, ACE_Recursive_Thread_Mutex >

friend class ACE_Singleton< SecurityRegistry, ACE_Recursive_Thread_Mutex >

friend

Definition at line 88 of file SecurityRegistry.h.

Member Data Documentation

ACCESS_CTRL_PLUGIN_NAME

const char * OpenDDS::Security::SecurityRegistry::ACCESS_CTRL_PLUGIN_NAME = "access_ctrl_plugin"

staticprivate

Definition at line 93 of file SecurityRegistry.h.

AUTHENTICATION_PLUGIN_NAME

const char * OpenDDS::Security::SecurityRegistry::AUTHENTICATION_PLUGIN_NAME = "auth_plugin"

staticprivate

Definition at line 94 of file SecurityRegistry.h.

builtin_config_

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::builtin_config_

mutableprivate

Definition at line 149 of file SecurityRegistry.h.

Referenced by builtin_config().

BUILTIN_CONFIG_NAME

const char * OpenDDS::Security::SecurityRegistry::BUILTIN_CONFIG_NAME = "_OPENDDS_BUILTIN_CONFIG"

static

Definition at line 44 of file SecurityRegistry.h.

config_entries_

ConfigEntryMap OpenDDS::Security::SecurityRegistry::config_entries_

private

Definition at line 144 of file SecurityRegistry.h.

Referenced by create_config(), and load_security_configuration().

config_map_

ConfigMap OpenDDS::Security::SecurityRegistry::config_map_

private

Definition at line 145 of file SecurityRegistry.h.

Referenced by add_config(), find_config(), get_config(), has_no_configs(), and release().

CRYPTO_PLUGIN_NAME

const char * OpenDDS::Security::SecurityRegistry::CRYPTO_PLUGIN_NAME = "crypto_plugin"

staticprivate

Definition at line 95 of file SecurityRegistry.h.

default_config_

SecurityConfig_rch OpenDDS::Security::SecurityRegistry::default_config_

mutableprivate

Definition at line 148 of file SecurityRegistry.h.

Referenced by default_config().

DEFAULT_CONFIG_NAME

const char * OpenDDS::Security::SecurityRegistry::DEFAULT_CONFIG_NAME = "_OPENDDS_DEFAULT_CONFIG"

static

Definition at line 43 of file SecurityRegistry.h.

Referenced by OpenDDS::Security::BuiltInPluginLoader::init().

DEFAULT_INST_PREFIX

const char * OpenDDS::Security::SecurityRegistry::DEFAULT_INST_PREFIX = "_OPENDDS_"

staticprivate

Definition at line 90 of file SecurityRegistry.h.

default_load_lock_

LockType OpenDDS::Security::SecurityRegistry::default_load_lock_

mutableprivate

Definition at line 152 of file SecurityRegistry.h.

Referenced by builtin_config().

DEFAULT_PLUGIN_NAME

const char * OpenDDS::Security::SecurityRegistry::DEFAULT_PLUGIN_NAME = "BuiltIn"

staticprivate

Definition at line 91 of file SecurityRegistry.h.

Referenced by builtin_config(), and SecurityRegistry().

lib_directive_map_

LibDirectiveMap OpenDDS::Security::SecurityRegistry::lib_directive_map_

private

Definition at line 147 of file SecurityRegistry.h.

Referenced by builtin_config(), load_security_plugin_lib(), and SecurityRegistry().

lock_

LockType OpenDDS::Security::SecurityRegistry::lock_

mutableprivate

Definition at line 151 of file SecurityRegistry.h.

Referenced by add_config(), builtin_config(), default_config(), find_config(), get_config(), get_plugin_inst(), has_no_configs(), load_security_plugin_lib(), register_plugin(), and release().

registered_plugins_

InstMap OpenDDS::Security::SecurityRegistry::registered_plugins_

private

Definition at line 146 of file SecurityRegistry.h.

Referenced by get_plugin_inst(), register_plugin(), and release().

SECURITY_SECTION_NAME

const char * OpenDDS::Security::SecurityRegistry::SECURITY_SECTION_NAME = "security"

staticprivate

Definition at line 92 of file SecurityRegistry.h.

Referenced by load_security_configuration().

---

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

• SecurityRegistry.h
• SecurityRegistry.cpp