void
TAO_NT_Notify_Service::handle_control (DWORD control_code)
{
if (control_code == SERVICE_CONTROL_SHUTDOWN
|| control_code == SERVICE_CONTROL_STOP)
{
report_status (SERVICE_STOP_PENDING);
TAO_ORB_Core_instance ()->reactor ()->end_reactor_event_loop ();
TAO_ORB_Core_instance ()->orb ()->shutdown (1);
report_status (SERVICE_STOPPED);
}
else
ACE_NT_Service::handle_control (control_code);
}
ACE_Reactor*
Consumer_Handler::reactor(void)
{
// @@ Please see if there's a way to get to the Reactor without
// using the TAO_ORB_Core_instance().
return TAO_ORB_Core_instance ()->reactor ();
}
int
Supplier_Input_Handler::close (void)
{
ACE_DEBUG ((LM_DEBUG,
"closing down Supplier::Supplier_Input_Handler\n"));
// Make sure to cleanup the STDIN handler.
if (ACE_Event_Handler::remove_stdin_handler
(
TAO_ORB_Core_instance ()->reactor (),
TAO_ORB_Core_instance ()->thr_mgr ()) == -1)
ACE_ERROR ((LM_ERROR,
"%p\n",
"remove_stdin_handler"));
return 0;
}
// Get ourselves a Naming service reference
int
TAO_AV_Endpoint_Process_Strategy::bind_to_naming_service (void)
{
try
{
if (CORBA::is_nil (this->naming_context_.in ()) == 0)
return 0;
CORBA::Object_var naming_obj =
TAO_ORB_Core_instance ()->orb ()->resolve_initial_references ("NameService");
if (CORBA::is_nil (naming_obj.in ()))
ORBSVCS_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to resolve the Name Service.\n"),
-1);
this->naming_context_ =
CosNaming::NamingContext::_narrow (naming_obj.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"TAO_AV_Endpoint_Process_Strategy::bind_to_naming_service");
return -1;
}
return 0;
}
int
Supplier_Input_Handler::initialize (Notifier_Handler *notifier)
{
notifier_ = notifier;
// Register our <Input_Handler> to handle STDIN events, which will
// trigger the <handle_input> method to process these events.
if (ACE_Event_Handler::register_stdin_handler
(this,
TAO_ORB_Core_instance ()->reactor (),
TAO_ORB_Core_instance ()->thr_mgr ()) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
"%p\n",
"register_stdin_handler"),
-1);
return 0;
}
int
Locator_Repository::setup_multicast (ACE_Reactor* reactor, const char* ior)
{
ACE_ASSERT (reactor != 0);
#if defined (ACE_HAS_IP_MULTICAST)
TAO_ORB_Core* core = TAO_ORB_Core_instance ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (core->orb_params ()->mcast_discovery_endpoint ());
if (mde.length () != 0)
{
if (this->ior_multicast_.init (ior,
mde.c_str (), TAO_SERVICEID_IMPLREPOSERVICE) == -1)
{
return -1;
}
}
else
{
// Port can be specified as param, env var, or default
CORBA::UShort port =
core->orb_params ()->service_port (TAO::MCAST_IMPLREPOSERVICE);
if (port == 0)
{
// Check environment var. for multicast port.
const char* port_number = ACE_OS::getenv ("ImplRepoServicePort");
if (port_number != 0)
port = static_cast<CORBA::UShort> (ACE_OS::atoi (port_number));
}
if (port == 0)
port = TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT;
if (this->ior_multicast_.init (ior, port,
ACE_DEFAULT_MULTICAST_ADDR, TAO_SERVICEID_IMPLREPOSERVICE) == -1)
{
return -1;
}
}
// Register event handler for the ior multicast.
if (reactor->register_handler (&this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
{
if (this->opts_.debug() > 0)
ORBSVCS_DEBUG ((LM_DEBUG, "ImR: cannot register Event handler\n"));
return -1;
}
#else /* ACE_HAS_IP_MULTICAST*/
ACE_UNUSED_ARG (reactor);
ACE_UNUSED_ARG (ior);
#endif /* ACE_HAS_IP_MULTICAST*/
return 0;
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
TAO_Stub::TAO_Stub (const char *repository_id,
const TAO_MProfile &profiles,
TAO_ORB_Core *orb_core)
: type_id (repository_id)
, orb_core_ (orb_core)
, orb_ ()
, is_collocated_ (false)
, servant_orb_ ()
, collocated_servant_ (0)
, object_proxy_broker_ (the_tao_remote_object_proxy_broker ())
, base_profiles_ ((CORBA::ULong) 0)
, forward_profiles_ (0)
, forward_profiles_perm_ (0)
, profile_in_use_ (0)
, profile_success_ (false)
, refcount_ (1)
#if (TAO_HAS_CORBA_MESSAGING == 1)
, policies_ (0)
#endif
, ior_info_ (0)
, forwarded_ior_info_ (0)
, collocation_opt_ (orb_core->optimize_collocation_objects ())
, forwarded_on_exception_ (false)
{
if (this->orb_core_.get() == 0)
{
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO: (%P|%t) TAO_Stub created with default ")
ACE_TEXT ("ORB core\n")));
}
this->orb_core_.reset (TAO_ORB_Core_instance ());
}
// Duplicate the ORB_Core, otherwise the allocators and other
// resources that this class references (directly or indirectly)
// could be destroyed before it is time.
(void) this->orb_core_->_incr_refcnt ();
// Cache the ORB pointer to respond faster to certain queries.
this->orb_ = CORBA::ORB::_duplicate (this->orb_core_->orb ());
// Explicit trigger the loading of the client strategy factory at this moment.
// Not doing it here could lead to a problem loading it later on during
// an upcall
(void) this->orb_core_->client_factory ();
this->base_profiles (profiles);
}
void
Object_A_i::foo (Initiator_ptr theInitiator_ptr)
{
try
{
theInitiator_ptr->foo_object_B ();
while (!this->finish_two_way_call_)
TAO_ORB_Core_instance ()->reactor ()->handle_events ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("calling the initiator");
}
}
CORBA::InterfaceDef_ptr
TAO_DynamicImplementation::_get_interface (void)
{
TAO_IFR_Client_Adapter *adapter =
ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
TAO_ORB_Core::ifr_client_adapter_name ());
if (adapter == 0)
{
throw ::CORBA::INTF_REPOS ();
}
CORBA::RepositoryId_var id = this->get_id_from_primary_interface ();
// This doesn't take multiple ORBs into account, but it's being
// used only to resolve the IFR, so we should be ok.
return adapter->get_interface (TAO_ORB_Core_instance ()->orb (), id.in ());
}
CORBA::Boolean
TAO::Unknown_IDL_Type::to_abstract_base (CORBA::AbstractBase_ptr & obj) const
{
try
{
CORBA::TCKind const kind = TAO::unaliased_kind (this->type_);
if (kind != CORBA::tk_abstract_interface)
{
return false;
}
TAO_ORB_Core *orb_core = this->cdr_.orb_core ();
if (orb_core == 0)
{
orb_core = TAO_ORB_Core_instance ();
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG ((LM_WARNING,
ACE_TEXT ("TAO (%P|%t) WARNING: extracting ")
ACE_TEXT ("abstract base using default ORB_Core\n")));
}
}
// We don't want the rd_ptr to move, in case we are shared by
// another Any, so we use this to copy the state, not the buffer.
TAO_InputCDR for_reading (this->cdr_);
TAO_Valuetype_Adapter * const adapter =
orb_core->valuetype_adapter ();
CORBA::Boolean ret = adapter->stream_to_abstract_base (for_reading, obj);
return ret;
}
catch (::CORBA::Exception const &)
{
}
return false;
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
// Constructor.
TAO_Time_Service_Clerk::TAO_Time_Service_Clerk (int timer_value,
int timer_value_usecs,
const IORS& servers)
: server_ (servers),
helper_ (this)
{
// Schedule the helper to be invoked by the reactor
// periodically.
if (TAO_ORB_Core_instance ()->reactor ()->schedule_timer
(&helper_,
0,
ACE_Time_Value::zero,
ACE_Time_Value(timer_value,timer_value_usecs)) == -1)
ORBSVCS_ERROR ((LM_ERROR,
"%p\n",
"schedule_timer ()"));
}
//
// Measures how well the reverse hash map works.
//
void
reverse_map_effectiveness (test_i *servants)
{
// Size of the active object map
const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters ¶meters =
TAO_ORB_Core_instance ()->server_factory ()->active_object_map_creation_parameters ();
u_long active_object_map_size = parameters.active_object_map_size_;
// Hash counters
u_long *hash_counter = new u_long[active_object_map_size];
// Index counter
u_long i = 0;
// Initialize the hash counters
for (i = 0; i < active_object_map_size; i++)
{
hash_counter[i] = 0;
}
// Calculate the effectiveness of the hash.
for (i = 0; i < iterations; i++)
{
u_long hash_index = ACE_Utils::truncate_cast<u_long> ((intptr_t)&servants[i]) % active_object_map_size;
hash_counter[hash_index]++;
}
for (i = 0; i < active_object_map_size; i++)
{
if (((i) % 10) == 0)
{
ACE_DEBUG ((LM_DEBUG, "\n"));
}
ACE_DEBUG ((LM_DEBUG, "%d = %d, ", i, hash_counter[i]));
}
ACE_DEBUG ((LM_DEBUG, "\n\n"));
delete[] hash_counter;
}
// Creates and returns a "B" type endpoint
int
TAO_AV_Endpoint_Process_Strategy_B::create_B (AVStreams::StreamEndPoint_B_ptr &stream_endpoint,
AVStreams::VDev_ptr &vdev)
{
try
{
if (this->activate () == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"(%P|%t) TAO_AV_Endpoint_Process_Strategy: Error in activate ()\n"),
-1);
if (TAO_debug_level > 0) ORBSVCS_DEBUG ((LM_DEBUG,"(%P|%t)TAO_AV_Endpoint_Process_Strategy_B::create_B ()\n: stream_endpoint is:%s\n",
TAO_ORB_Core_instance ()->orb ()->object_to_string (this->stream_endpoint_b_.in())));
stream_endpoint = AVStreams::StreamEndPoint_B::_duplicate ( this->stream_endpoint_b_.in() );
vdev = AVStreams::VDev::_duplicate( this->vdev_.in() );
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
"TAO_AV_Endpoint_Process_Strategy_B::create_B\n");
return -1;
}
return 0;
}
void
CORBA::ValueBase::_tao_unmarshal_find_factory (
TAO_InputCDR &strm,
void *const start_of_valuetype,
CORBA::ValueBase *&valuetype,
Repository_Id_List &ids,
CORBA::Boolean &is_chunked)
{
valuetype = 0;
TAO_ORB_Core *orb_core = strm.orb_core ();
if (!orb_core)
{
orb_core = TAO_ORB_Core_instance ();
if (TAO_debug_level)
{
TAOLIB_DEBUG ((
LM_WARNING,
ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ")
ACE_TEXT ("WARNING: extracting valuetype using default ORB_Core\n") ));
}
}
// Find the registered factory for this unmarshalling valuetype. If any
// factory for the valuetype in its truncatable derivation hierarchy
// is registered, the factory is used to create value for unmarshalling.
// Value factories are reference counted. When we get a new value factory
// from the ORB, its reference count is increased.
CORBA::ValueFactory_var factory;
CORBA::Boolean requires_truncation = false;
const size_t num_ids = ids.size ();
const char *id = (num_ids) ? ids[0].c_str () : "{Null}";
for (size_t i = 0u; i < num_ids; ++i)
{
factory = orb_core->orb ()->lookup_value_factory (ids[i].c_str ());
if (factory.in() != 0)
{
id = ids[i].c_str ();
requires_truncation = (i != 0u);
break;
}
}
// Obtain the actual ValueType from the factory
if (factory.in() == 0 || !(valuetype = factory->create_for_unmarshal ()))
{
if (TAO_debug_level)
{
TAOLIB_ERROR ((LM_ERROR,
ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ")
ACE_TEXT ("OBV factory is null, id=%C\n"),
id));
}
throw ::CORBA::MARSHAL (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
}
if (requires_truncation)
{
valuetype->truncation_hook ();
}
valuetype->chunking_ = is_chunked;
// Cache the start of this ValueType for later possiable indirection
VERIFY_MAP (TAO_InputCDR, value_map, Value_Map);
if (strm.get_value_map ()->get()->bind (start_of_valuetype, valuetype) != 0)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ")
ACE_TEXT ("Failed to bound value %x=%x, id=%C\n"),
start_of_valuetype, valuetype, id ));
}
else if (TAO_debug_level)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ")
ACE_TEXT ("bound value %x=%x, id=%C\n"),
start_of_valuetype, valuetype, id ));
}
}
int
TAO_Trading_Loader::init_multicast_server (void)
{
#if defined (ACE_HAS_IP_MULTICAST)
// Get reactor instance from TAO.
ACE_Reactor *reactor = TAO_ORB_Core_instance ()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (TAO_ORB_Core_instance ()->orb_params ()
->mcast_discovery_endpoint ());
// First, see if the user has given us a multicast port number for
// the name service on the command-line;
u_short port =
TAO_ORB_Core_instance ()->orb_params ()->service_port (TAO::MCAST_TRADINGSERVICE);
if (port == 0)
{
const char *port_number =
ACE_OS::getenv ("TradingServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
else
port = TAO_DEFAULT_TRADING_SERVER_REQUEST_PORT;
}
// Instantiate a server that will receive requests for an ior
if (mde.length () != 0)
{
if (this->ior_multicast_.init ((char *) this->ior_.in (),
mde.c_str (),
TAO_SERVICEID_TRADINGSERVICE) == -1)
return -1;
}
else
{
if (this->ior_multicast_.init ((char *) this->ior_.in (),
port,
ACE_DEFAULT_MULTICAST_ADDR,
TAO_SERVICEID_TRADINGSERVICE) == -1)
ORBSVCS_ERROR_RETURN ((LM_ERROR,
"Failed to init IOR multicast.\n"),
-1);
}
// Register event handler for the ior multicast.
if (reactor->register_handler (&this->ior_multicast_,
ACE_Event_Handler::READ_MASK) == -1)
ORBSVCS_DEBUG ((LM_DEBUG,
"cannot register Event handler\n"));
else
ORBSVCS_DEBUG ((LM_DEBUG,
"The multicast server setup is done.\n"));
// Other trader instances will bootstrap to us.
this->bootstrapper_ = 1;
#endif /* ACE_HAS_IP_MULTICAST */
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
// Obtain the RootPOA.
CORBA::Object_var obj =
orb->resolve_initial_references ("RootPOA");
PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in ());
const TAO_Server_Strategy_Factory::Active_Object_Map_Creation_Parameters &creation_parameters
= TAO_ORB_Core_instance ()->server_factory ()->active_object_map_creation_parameters ();
int perform_deactivation_test = creation_parameters.allow_reactivation_of_system_ids_;
PortableServer::POA_var first_poa;
PortableServer::POA_var second_poa;
PortableServer::POA_var third_poa;
PortableServer::POA_var forth_poa;
create_poas (root_poa.in (),
PortableServer::TRANSIENT,
first_poa.out (),
second_poa.out (),
third_poa.out (),
forth_poa.out ());
test_poas (orb.in (),
root_poa.in (),
first_poa.in (),
second_poa.in (),
third_poa.in (),
forth_poa.in (),
perform_deactivation_test);
first_poa->destroy (1,
1);
second_poa->destroy (1,
1);
third_poa->destroy (1,
1);
forth_poa->destroy (1,
1);
create_poas (root_poa.in (),
PortableServer::PERSISTENT,
first_poa.out (),
second_poa.out (),
third_poa.out (),
forth_poa.out ());
test_poas (orb.in (),
root_poa.in (),
first_poa.in (),
second_poa.in (),
third_poa.in (),
forth_poa.in (),
perform_deactivation_test);
root_poa->destroy (1,
1);
orb->destroy ();
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception!");
return -1;
}
return 0;
}
CosLifeCycle::Factories *
Quoter_Factory_Finder_i::find_factories (const CosLifeCycle::Key &factory_key)
{
const char *exception_message = "Null Message";
CosLifeCycle::Factories *factories_ptr = 0;
try
{
// Get a reference to the ORB.
CORBA::ORB_ptr orb_ptr = TAO_ORB_Core_instance ()->orb ();
// Get the Naming Service object reference.
exception_message = "While resolving the Name Service";
CORBA::Object_var namingObj_var =
orb_ptr->resolve_initial_references ("NameService");
if (CORBA::is_nil (namingObj_var.in ()))
ACE_ERROR ((LM_ERROR,
" (%P|%t) Unable get the Naming Service.\n"));
// Narrow the object reference to a Naming Context.
exception_message = "While narrowing the Naming Context";
CosNaming::NamingContext_var namingContext_var =
CosNaming::NamingContext::_narrow (namingObj_var.in ());
// Take the key supplied to search for a Quoter Factory
CosNaming::Name factoryName = (CosNaming::Name) factory_key;
// Try to get a reference to a Quoter Factory
exception_message = "While resolving the Factory Object";
CORBA::Object_var quoterFactoryObject_var =
namingContext_var->resolve (factoryName);
// Check if it is a valid Quoter Factory reference
if (CORBA::is_nil (quoterFactoryObject_var.in()))
throw CosLifeCycle::NoFactory (factory_key);
// create a sequence of factories object
factories_ptr = new CosLifeCycle::Factories (1);
// using the Naming Service only one reference is available
factories_ptr->length (1);
// Check if it is a valid Quoter Factory reference.
if (CORBA::is_nil (quoterFactoryObject_var.in ())) // throw a NoFactory exception.
throw CosLifeCycle::NoFactory (factory_key);
// insert the object reference
(*factories_ptr)[0] = CORBA::Object::_duplicate (quoterFactoryObject_var.in());
if (this->debug_level_ > 1)
ACE_DEBUG ((LM_DEBUG,
"Factory Finder: Have reference to a Quoter Factory.\n"));
}
catch (const CORBA::Exception&)
{
ACE_ERROR ((LM_ERROR, "Quoter_Factory_Finder::find_factories - %C\n", exception_message));
throw CosLifeCycle::NoFactory (factory_key);
}
return factories_ptr;
}
int
DualEC_Supplier::init ()
{
this->get_options (argc_, argv_);
try
{
// Connect to the RootPOA.
CORBA::Object_var poaObject_var =
TAO_ORB_Core_instance()->orb()->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poaObject_var.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
this->root_POA_var_ =
PortableServer::POA::_narrow (poaObject_var.in ());
this->poa_manager_ =
root_POA_var_->the_POAManager ();
poa_manager_->activate ();
// Get the Naming Service object reference.
CORBA::Object_var namingObj_var =
TAO_ORB_Core_instance()->orb()->resolve_initial_references (
"NameService");
if (CORBA::is_nil (namingObj_var.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to get the Naming Service.\n"),
-1);
this->naming_context_ =
CosNaming::NamingContext::_narrow (namingObj_var.in ());
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("DualEC_Supplier::init");
return -1;
}
// Create two scheduling service instances.
if (this->create_schedulers () == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not create schedulers"),
-1);
}
// Create two event channels.
if (this->create_event_channels () == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not create event channels"),
-1);
}
// Connect suppliers to the respective event channels.
ACE_Scheduler_Factory::POD_RT_Info * rt_info_nav_hi =
(suppress_priority_) ? 0 : &rt_info_nav_hi_;
ACE_Scheduler_Factory::POD_RT_Info * rt_info_weap_hi =
(suppress_priority_) ? 0 : &rt_info_weap_hi_;
ACE_Scheduler_Factory::POD_RT_Info * rt_info_nav_lo =
(suppress_priority_) ? 0 : &rt_info_nav_lo_;
ACE_Scheduler_Factory::POD_RT_Info * rt_info_weap_lo =
(suppress_priority_) ? 0 : &rt_info_weap_lo_;
if (this->navigation_Supplier_.connect ("MIB_unknown",
"DUAL_EC_HI",
"DUAL_SCHED_HI",
rt_info_nav_hi) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not connect navigation supplier to DUAL_EC_HI"),
-1);
}
if (this->navigation_Supplier_.connect ("MIB_unknown",
"DUAL_EC_LO",
"DUAL_SCHED_LO",
rt_info_nav_lo) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not connect navigation supplier to DUAL_EC_LO"),
-1);
}
if (this->weapons_Supplier_.connect ("MIB_unknown",
"DUAL_EC_HI",
"DUAL_SCHED_HI",
rt_info_weap_hi) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not connect weapons supplier to DUAL_EC_HI"),
-1);
}
if (this->weapons_Supplier_.connect ("MIB_unknown",
"DUAL_EC_LO",
"DUAL_SCHED_LO",
rt_info_weap_lo) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
"Could not connect weapons supplier to DUAL_EC_LO"),
-1);
}
return 0;
}
// Install ior multicast handler.
int
TAO_IFR_Server::init_multicast_server (void)
{
#if defined (ACE_HAS_IP_MULTICAST)
// Get reactor instance from TAO.
ACE_Reactor *reactor = this->orb_->orb_core ()->reactor ();
// See if the -ORBMulticastDiscoveryEndpoint option was specified.
ACE_CString mde (
TAO_ORB_Core_instance ()->orb_params ()->mcast_discovery_endpoint ()
);
// First, see if the user has given us a multicast port number
// on the command-line;
u_short port =
TAO_ORB_Core_instance ()->orb_params ()->service_port (
TAO::MCAST_INTERFACEREPOSERVICE
);
if (port == 0)
{
// Check environment var. for multicast port.
const char *port_number =
ACE_OS::getenv ("InterfaceRepoServicePort");
if (port_number != 0)
port = static_cast<u_short> (ACE_OS::atoi (port_number));
}
// Port wasn't specified on the command-line or in environment -
// use the default.
if (port == 0)
port = TAO_DEFAULT_INTERFACEREPO_SERVER_REQUEST_PORT;
// Instantiate a handler which will handle client requests for
// the IFR ior, received on the multicast port.
ACE_NEW_THROW_EX (this->ior_multicast_,
TAO_IOR_Multicast (),
CORBA::NO_MEMORY ());
if (mde.length () != 0)
{
if (this->ior_multicast_->init (this->ifr_ior_.in (),
mde.c_str (),
TAO_SERVICEID_INTERFACEREPOSERVICE)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot initialize ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
}
else
{
if (this->ior_multicast_->init (this->ifr_ior_.in (),
port,
ACE_DEFAULT_MULTICAST_ADDR,
TAO_SERVICEID_INTERFACEREPOSERVICE)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot initialize ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
}
// Register event handler for the ior multicast.
if (reactor->register_handler (this->ior_multicast_,
ACE_Event_Handler::READ_MASK)
== -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("Interface Repository: cannot register ")
ACE_TEXT ("multicast event handler\n")
),
-1
);
}
#endif /* ACE_HAS_IP_MULTICAST */
return 0;
}
void
DualEC_Supplier::Terminator::shutdown (void)
{
TAO_ORB_Core_instance ()->orb ()->shutdown ();
}
ACE_THR_FUNC_RETURN
DualEC_Supplier::run_orb (void *)
{
TAO_ORB_Core_instance ()->orb ()->run ();
return 0;
}
ACE_Reactor *
Notifier_Server::reactor (void)
{
return TAO_ORB_Core_instance ()->reactor ();
}
