TAO_BEGIN_VERSIONED_NAMESPACE_DECL
TAO::SSLIOP::Server_Invocation_Interceptor::Server_Invocation_Interceptor
(
PortableInterceptor::ORBInitInfo_ptr info,
::Security::QOP default_qop,
size_t tss_slot
)
: qop_ (default_qop)
{
/*
* Cache references to the "Current" objects that we'll need during
* during invocations.
*/
CORBA::Object_var obj =
info->resolve_initial_references ("SSLIOPCurrent");
this->ssliop_current_ = ::SSLIOP::Current::_narrow (obj.in ());
if (!CORBA::is_nil (this->ssliop_current_.in ()))
{
TAO::SSLIOP::Current *tao_current =
dynamic_cast<TAO::SSLIOP::Current *> (this->ssliop_current_.in ());
if (tao_current != 0)
{
if (TAO_debug_level > 3)
ORBSVCS_DEBUG ((LM_DEBUG, "TAO (%P|%t) SSLIOP_Invocation_Interceptor::CTOR--setting up SSLIOP Current with slot %d\n", tss_slot));
tao_current->tss_slot (tss_slot);
}
else
throw CORBA::INTERNAL ();
}
obj = info->resolve_initial_references ("SecurityLevel2:SecurityManager");
this->sec2manager_ = SecurityLevel2::SecurityManager::_narrow (obj.in ());
if (! CORBA::is_nil (this->sec2manager_.in ()))
{
// set the slot id? things seem to work without doing this
}
#if 0
// Don't need this now that we're not using access_allowed(), but
// I'm leaving the code here just in case it would become convenient
// for some other use.
obj = info->resolve_initial_references ("POACurrent");
this->poa_current_ = PortableServer::Current::_narrow (obj.in ());
#endif
}
void
TAO_RTScheduler_ORB_Initializer::post_init (PortableInterceptor::ORBInitInfo_ptr info)
{
// @@ This is busted. TAO_ORBInitInfo should do proper reference
// counting.
// Narrow to a TAO_ORBInitInfo object to get access to the
// orb_core() TAO extension.
//TAO_ORBInitInfo_var tao_info = TAO_ORBInitInfo::_narrow (info
// );
if (TAO_debug_level > 0)
TAOLIB_DEBUG ((LM_DEBUG,
"In post_init\n"));
CORBA::Object_var rt_current_obj =
info->resolve_initial_references (TAO_OBJID_RTCURRENT);
RTCORBA::Current_var rt_current =
RTCORBA::Current::_narrow (rt_current_obj.in ());
if (CORBA::is_nil (rt_current.in ()))
{
TAOLIB_DEBUG ((LM_DEBUG,
"(%P|%t) ::post_init\n"
"(%P|%t) Unable to narrow to RTCORBA::Current\n"));
throw ::CORBA::INTERNAL ();
}
this->current_->rt_current (rt_current.in ());
}
size_t
TAO::SSLIOP::ORBInitializer::get_tss_slot_id (
PortableInterceptor::ORBInitInfo_ptr info)
{
// Obtain the Security Service TSS slot ID from the SecurityCurrent
// object.
CORBA::Object_var obj =
info->resolve_initial_references ("SecurityLevel3:SecurityCurrent");
SecurityLevel3::SecurityCurrent_var current =
SecurityLevel3::SecurityCurrent::_narrow (obj.in ());
TAO::SL3::SecurityCurrent * security_current =
dynamic_cast<TAO::SL3::SecurityCurrent *> (current.in ());
if (security_current == 0)
{
ORBSVCS_DEBUG ((LM_DEBUG,
"Unable to obtain TSS slot ID from "
"\"SecurityCurrent\" object.\n"));
throw CORBA::INTERNAL ();
}
return security_current->tss_slot ();
}
void
ClientInitializer::post_init (PortableInterceptor::ORBInitInfo_ptr info)
{
// Find the Naming Service
CORBA::Object_var naming_obj =
info->resolve_initial_references("NameService");
CosNaming::NamingContext_var root =
CosNaming::NamingContext::_narrow(naming_obj.in());
if( CORBA::is_nil(root.in())) {
std::cerr << "Nil Naming Context reference" << std::endl;
ACE_ASSERT(false);
}
// Resolve the Messenger object
CosNaming::Name name;
name.length( 1 );
name[0].id = CORBA::string_dup( "Messenger" );
CORBA::Object_var obj = CORBA::Object::_nil();
while ( CORBA::is_nil( obj.in() ) ) {
try {
obj = root->resolve( name );
} catch (const CosNaming::NamingContext::NotFound&) {
// Sleep for a second and try again
ACE_OS::sleep(1);
}
}
Messenger_var messenger = Messenger::_narrow( obj.in() );
if( CORBA::is_nil( messenger.in() ) ) {
std::cerr << "Not a Messenger reference" << std::endl;
ACE_ASSERT(false);
}
// allocate slot
slot_ = info->allocate_slot_id();
// get PICurrent
CORBA::Object_var current_obj = info->resolve_initial_references("PICurrent");
current_ =
PortableInterceptor::Current::_narrow(current_obj.in());
// Create and register the request interceptors.
PortableInterceptor::ClientRequestInterceptor_var ci =
new ClientInterceptor(messenger, current_.in(), slot_);
info->add_client_request_interceptor (ci.in());
}
void
ServerORBInitializer::post_init (
PortableInterceptor::ORBInitInfo_ptr info)
{
CORBA::Object_var obj =
info->resolve_initial_references ("POACurrent");
PortableServer::Current_var poa_current =
PortableServer::Current::_narrow (obj.in ());
ACE_ASSERT (!CORBA::is_nil (poa_current.in ()));
CORBA::String_var orb_id = info->orb_id ();
// Create and register the test's ServerRequestInterceptor
PortableInterceptor::ServerRequestInterceptor_ptr tmp;
ACE_NEW_THROW_EX (tmp,
ServerRequestInterceptor (orb_id.in (),
poa_current.in ()),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ServerRequestInterceptor_var server_interceptor = tmp;
info->add_server_request_interceptor (server_interceptor.in ());
// Create and register the test's IORInterceptor
PortableInterceptor::IORInterceptor_ptr ort_test_interceptor;
ACE_NEW_THROW_EX (ort_test_interceptor,
ORT_test_IORInterceptor,
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::IORInterceptor_var ior_interceptor =
ort_test_interceptor;
info->add_ior_interceptor (ior_interceptor.in ());
}
void
TAO_LB_ORBInitializer::post_init (
PortableInterceptor::ORBInitInfo_ptr info)
{
CORBA::Object_var obj =
info->resolve_initial_references ("LoadManager");
CosLoadBalancing::LoadManager_var lm =
CosLoadBalancing::LoadManager::_narrow (obj.in ());
CORBA::String_var orbid = info->orb_id ();
PortableInterceptor::IORInterceptor_ptr tmp;
ACE_NEW_THROW_EX (tmp,
TAO_LB_IORInterceptor (this->object_groups_,
this->repository_ids_,
this->location_.in (),
lm.in (),
orbid.in (),
this->load_alert_),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::IORInterceptor_var ior_interceptor = tmp;
info->add_ior_interceptor (ior_interceptor.in ());
// ----------------
PortableInterceptor::ServerRequestInterceptor_ptr sri;
ACE_NEW_THROW_EX (sri,
TAO_LB_ServerRequestInterceptor (this->load_alert_),
CORBA::NO_MEMORY (
CORBA::SystemException::_tao_minor_code (
TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ServerRequestInterceptor_var sr_interceptor = sri;
info->add_server_request_interceptor (sr_interceptor.in ());
}
void
ORBInitializerImpl::post_init (PortableInterceptor::ORBInitInfo_ptr info)
{
//
// First resolve the Name Service
//
CORBA::Object_var obj;
try
{
obj = info->resolve_initial_references("NameService");
}
catch (const CORBA::ORB::InvalidName&)
{
std::cerr << "ORBInitializerImpl: Can't resolve NameService" << std::endl;
return;
}
if (CORBA::is_nil(obj.in()))
{
std::cerr << "ORBInitializerImpl: NameService is a nil object reference" << std::endl;
return;
}
try
{
nameService_ = CosNaming::NamingContext::_narrow(obj.in());
}
catch (const CORBA::Exception&)
{
std::cerr << "ORBInitializerImpl: NameService is not running" << std::endl;
return;
}
if (CORBA::is_nil(nameService_.in()))
{
std::cerr << "ORBInitializerImpl: NameService is not a NamingContext object reference" << std::endl;
return;
}
//
// Resolve the HomeFinder
//
Qedo_Components::HomeFinder_var home_finder;
obj = resolveName("Qedo/HomeFinder");
if (CORBA::is_nil(obj.in()))
{
std::cerr << "ORBInitializerImpl: HomeFinder not found" << std::endl;
return;
}
try
{
home_finder = Qedo_Components::HomeFinder::_narrow(obj);
}
catch (CORBA::SystemException&)
{
std::cerr << "ORBInitializerImpl: HomeFinder is not running" << std::endl;
return;
}
if (CORBA::is_nil(home_finder.in()))
{
std::cerr << "ORBInitializerImpl: HomeFinder is not running" << std::endl;
return;
}
//
// register HomeFinder
//
info->register_initial_reference ("ComponentHomeFinder", home_finder);
//
// Allocate a slot id to communicate data towards our components
//
slot_id_ = info->allocate_slot_id();
}
void
TAO::SSLIOP::ORBInitializer::post_init (
PortableInterceptor::ORBInitInfo_ptr info)
{
// Note we do not store the SSLIOP::Current as a class member since
// we need to avoid potential problems where the same
// SSLIOP::Current object is shared between ORBs. Each ORB should
// have its own unique SSLIOP::Current object. By obtaining the
// SSLIOP::Current object from the resolve_initial_references()
// mechanism, we are guaranteed that the SSLIOP::Current object is
// specific to the ORB being initialized since a new SSLIOP::Current
// object is registered for each ORB in this ORBInitializer's
// pre_init() method.
// Create the SSLIOP secure invocation server request interceptor.
PortableInterceptor::ServerRequestInterceptor_ptr si =
PortableInterceptor::ServerRequestInterceptor::_nil ();
ACE_NEW_THROW_EX (si,
TAO::SSLIOP::Server_Invocation_Interceptor(
info,
this->qop_,
this->get_tss_slot_id (info)),
CORBA::NO_MEMORY (CORBA::SystemException::_tao_minor_code (TAO::VMCID,
ENOMEM),
CORBA::COMPLETED_NO));
PortableInterceptor::ServerRequestInterceptor_var si_interceptor =
si;
// Register the SSLIOP secure invocation server request interceptor
// with the ORB.
info->add_server_request_interceptor (si_interceptor.in ());
// TAO_ORBInitInfo_var tao_info =
// TAO_ORBInitInfo::_narrow (info
//);
// if (CORBA::is_nil (tao_info.in ()))
// ACE_THROW (CORBA::INV_OBJREF ());
// TAO_ORB_Core * orb_core = tao_info->orb_core ();
// // Create the SSLIOP IOR interceptor.
// PortableInterceptor::IORInterceptor_ptr ii =
// PortableInterceptor::IORInterceptor::_nil ();
// ACE_NEW_THROW_EX (ii,
// TAO::SSLIOP::IORInterceptor (orb_core,
// this->csiv2_target_supports_,
// this->csiv2_target_requires_),
// CORBA::NO_MEMORY (
// CORBA::SystemException::_tao_minor_code (
// TAO::VMCID,
// ENOMEM),
// CORBA::COMPLETED_NO));
// PortableInterceptor::IORInterceptor_var ior_interceptor =
// ii;
// // Register the SSLIOP IORInterceptor.
// info->add_ior_interceptor (ior_interceptor.in ()
//);
// Register the SSLIOP-specific vault with the
// PrincipalAuthenticator.
CORBA::Object_var obj =
info->resolve_initial_references ("SecurityLevel3:SecurityManager");
SecurityLevel3::SecurityManager_var manager =
SecurityLevel3::SecurityManager::_narrow (obj.in ());
SecurityLevel3::CredentialsCurator_var curator =
manager->credentials_curator ();
TAO::SL3::CredentialsCurator_var tao_curator =
TAO::SL3::CredentialsCurator::_narrow (curator.in ());
TAO::SSLIOP::CredentialsAcquirerFactory * factory;
ACE_NEW_THROW_EX (factory,
TAO::SSLIOP::CredentialsAcquirerFactory,
CORBA::NO_MEMORY ());
auto_ptr<TAO::SSLIOP::CredentialsAcquirerFactory> safe_factory;
tao_curator->register_acquirer_factory ("SL3TLS", factory);
(void) safe_factory.release (); // CredentialsCurator now owns
// CredentialsAcquirerFactory.
}