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. }