// This function does what TAO does in order to get a transport. CORBA::Boolean first_request_flag (CORBA::Object_ptr obj) { TAO_Stub *const stub = obj->_stubobj (); if (0 == stub) { ACE_ERROR_RETURN ((LM_DEBUG, "CORBA::Object has stub = 0\n"), 1); } TAO::Profile_Transport_Resolver resolver (obj, stub, true); resolver.resolve (0); TAO_Transport *transport = resolver.transport (); if (0 == transport) { ACE_ERROR_RETURN ((LM_DEBUG, "Transport is 0\n"), 1); } return transport->first_request (); }
TAO_IIOP_Connection_Handler::~TAO_IIOP_Connection_Handler (void) { if (TAO_debug_level > 9) { TAO_Transport *tport = this->transport (); TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::") ACE_TEXT("~IIOP_Connection_Handler, ") ACE_TEXT("this=%@, transport=%@\n"), tport != 0 ? tport->id () : 0, this, tport)); } delete this->transport (); int const result = this->release_os_resources (); if (result == -1 && TAO_debug_level) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler::") ACE_TEXT("~IIOP_Connection_Handler, ") ACE_TEXT("release_os_resources() failed %m\n"))); } }
void TAO_FIFO_Connection_Purging_Strategy::update_item (TAO_Transport& transport) { // FIFO, so only update the purging order if this // item has not been cached yet. if (transport.purging_order () == 0) { transport.purging_order (this->order_++); } }
ACE_Event_Handler::Reference_Count TAO_IIOP_Connection_Handler::remove_reference (void) { TAO_Transport *tport = this->transport (); Reference_Count rc = TAO_IIOP_SVC_HANDLER::remove_reference (); if (TAO_debug_level > 9) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::") ACE_TEXT("remove_reference, down to %d\n"), tport != 0 ? tport->id () : 0, rc)); } return rc; }
int TAO_Codeset_Service_Context_Handler::generate_service_context ( TAO_Stub *, TAO_Transport& transport, TAO_Operation_Details &opdetails, TAO_Target_Specification &, TAO_OutputCDR &) { if (transport.first_request ()) { TAO_Codeset_Manager * const csm = transport.orb_core ()->codeset_manager (); if (csm) { csm->generate_service_context (opdetails, transport); } } return 0; }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL #ifdef TAO_LOG_CH_REF_COUNTS ACE_Event_Handler::Reference_Count TAO_IIOP_Connection_Handler::add_reference (void) { Reference_Count rc = TAO_IIOP_SVC_HANDLER::add_reference (); if (TAO_debug_level > 9) { TAO_Transport *tport = this->transport (); TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::") ACE_TEXT("add_reference, up to %d\n"), tport != 0 ? tport->id () : 0, rc)); } return rc; }
int TAO_BiDIR_Service_Context_Handler::generate_service_context ( TAO_Stub *, TAO_Transport& transport, TAO_Operation_Details &opdetails, TAO_Target_Specification &, TAO_OutputCDR &msg) { if (transport.orb_core ()->bidir_giop_policy () && transport.messaging_object ()->is_ready_for_bidirectional (msg) && transport.bidirectional_flag () < 0) { transport.set_bidir_context_info (opdetails); // Set the flag to 1 (i.e., originating side) transport.bidirectional_flag (1); // At the moment we enable BiDIR giop we have to get a new // request id to make sure that we follow the even/odd rule // for request id's. We only need to do this when enabled // it, after that the Transport Mux Strategy will make sure // that the rule is followed opdetails.request_id (transport.tms ()->request_id ()); } return 0; }
TAO_BEGIN_VERSIONED_NAMESPACE_DECL int TAO_BiDIR_Service_Context_Handler::process_service_context ( TAO_Transport& transport, const IOP::ServiceContext& context, TAO_ServerRequest * /*request*/) { TAO_InputCDR cdr (reinterpret_cast<const char*> ( context.context_data.get_buffer ()), context.context_data.length ()); return transport.tear_listen_point_list (cdr); }
TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler ( TAO_ORB_Core *orb_core) : TAO_IIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0), TAO_Connection_Handler (orb_core), dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2) { TAO_IIOP_Transport* specific_transport = 0; ACE_NEW (specific_transport, TAO_IIOP_Transport (this, orb_core)); if (TAO_debug_level > 9) { TAO_Transport *tport = static_cast<TAO_Transport *> (specific_transport); TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT("TAO (%P|%t) - IIOP_Connection_Handler[%d]::") ACE_TEXT("IIOP_Connection_Handler, ") ACE_TEXT("this=%@\n"), tport != 0 ? tport->id () : 0, this)); } // store this pointer (indirectly increment ref count) this->transport (specific_transport); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA"); if (CORBA::is_nil (poa_object.in ())) ACE_ERROR_RETURN ((LM_ERROR, " (%P|%t) Unable to initialize the POA.\n"), 1); PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in ()); PortableServer::POAManager_var poa_manager = root_poa->the_POAManager (); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); if (CORBA::is_nil (policy_current.in ())) { ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n")); return 1; } CORBA::Any scope_as_any; scope_as_any <<= Messaging::SYNC_NONE; CORBA::PolicyList policies (1); policies.length (1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any); policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); if (parse_args (argc, argv) != 0) return 1; // Get the sender reference.. CORBA::Object_var tmp = orb->string_to_object(ior); Test::Sender_var sender = Test::Sender::_narrow(tmp.in ()); if (CORBA::is_nil (sender.in ())) { ACE_ERROR_RETURN ((LM_DEBUG, "Nil coordinator reference <%s>\n", ior), 1); } Client_Task client_task (orb.in(), sender.in (), ACE_Thread_Manager::instance (), number_of_oneways); Server_Task server_task (orb.in (), ACE_Thread_Manager::instance ()); // Before creating threads we will let the sender know that we // will have two threads that would make invocations.. // this is the first oneway we do, so after this we would have a queue // on one of the transports sender->active_objects ((CORBA::Short) number_of_client_tasks); TAO::Transport_Cache_Manager& manager = orb->orb_core()->lane_resources ().transport_cache (); TAO::Transport_Cache_Manager::HASH_MAP& cachemap = manager.map(); TAO::Transport_Cache_Manager::HASH_MAP_ITER end_iter = cachemap.end (); bool tranportwithqueue = false; for (TAO::Transport_Cache_Manager::HASH_MAP_ITER iter = cachemap.begin (); iter != end_iter; ++iter) { TAO_Transport* transport = (*iter).int_id_.transport (); if (transport->queue_is_empty() == 0 && transport->is_connected() == false) { tranportwithqueue = true; break; } } if (!tranportwithqueue) { ACE_ERROR ((LM_ERROR, "(%P|%t) Error: expect a not connected transport with a queue\n")); } else { ACE_DEBUG((LM_DEBUG, "(%P|%t) Found not connected transport with a queue\n")); } if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, 2,1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating server task\n")); } if (client_task.activate (THR_NEW_LWP | THR_JOINABLE, number_of_client_tasks, 1) == -1) { ACE_ERROR ((LM_ERROR, "Error activating client task\n")); } ACE_Thread_Manager::instance ()->wait (); ACE_DEBUG ((LM_DEBUG, "Event Loop finished\n")); orb->destroy (); if (tranportwithqueue == false) { return 1; } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("Exception caught:"); return 1; } return 0; }
TAO_Transport * TAO_UIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *max_wait_time) { if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - UIUP_Connector::make_connection, ") ACE_TEXT ("looking for UIOP connection.\n"))); TAO_UIOP_Endpoint *uiop_endpoint = this->remote_endpoint (desc.endpoint ()); if (uiop_endpoint == 0) return 0; const ACE_UNIX_Addr &remote_address = uiop_endpoint->object_addr (); if (TAO_debug_level > 2) TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - UIUP_Connector::make_connection, ") ACE_TEXT ("making a new connection\n"))); // Get the right synch options ACE_Synch_Options synch_options; this->active_connect_strategy_->synch_options (max_wait_time, synch_options); // The code used to set the timeout to zero, with the intent of // polling the reactor for connection completion. However, the side-effect // was to cause the connection to timeout immediately. TAO_UIOP_Connection_Handler *svc_handler = 0; // Connect. int result = this->base_connector_.connect (svc_handler, remote_address, synch_options); // Make sure that we always do a remove_reference ACE_Event_Handler_var svc_handler_auto_ptr (svc_handler); TAO_Transport *transport = svc_handler->transport (); if (result == -1) { // No immediate result, wait for completion if (errno == EWOULDBLOCK) { // Try to wait until connection completion. Incase we block, then we // get a connected transport or not. In case of non block we get // a connected or not connected transport if (!this->wait_for_connection_completion (r, desc, transport, max_wait_time)) { if (TAO_debug_level > 2) TAOLIB_ERROR ((LM_ERROR, "TAO (%P|%t) - UIOP_Connector::" "make_connection, " "wait for completion failed\n")); } } else { // Transport is not usable transport = 0; } } // In case of errors transport is zero if (transport == 0) { // Give users a clue to the problem. if (TAO_debug_level > 3) TAOLIB_ERROR ((LM_ERROR, "TAO (%P|%t) - UIOP_Connector::make_connection, " "connection to <%C> failed (%p)\n", uiop_endpoint->rendezvous_point (), ACE_TEXT("errno"))); return 0; } if (svc_handler->keep_waiting ()) { svc_handler->connection_pending (); } if (svc_handler->error_detected ()) { svc_handler->cancel_pending_connection (); } // At this point, the connection has be successfully created // connected or not connected, but we have a connection. if (TAO_debug_level > 2) TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - UIOP_Connector::make_connection, " "new %C connection to <%C> on Transport[%d]\n", transport->is_connected() ? "connected" : "not connected", uiop_endpoint->rendezvous_point (), svc_handler->peer ().get_handle ())); // Add the handler to Cache int retval = this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc, transport); // Failure in adding to cache. if (retval == -1) { // Close the handler. svc_handler->close (); if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - UIOP_Connector::make_connection, ") ACE_TEXT ("could not add the new connection to Cache\n"))); } return 0; } if (svc_handler->error_detected ()) { svc_handler->cancel_pending_connection (); transport->purge_entry(); return 0; } if (transport->is_connected () && transport->wait_strategy ()->register_handler () != 0) { // Registration failures. // Purge from the connection cache, if we are not in the cache, this // just does nothing. (void) transport->purge_entry (); // Close the handler. (void) transport->close_connection (); if (TAO_debug_level > 0) TAOLIB_ERROR ((LM_ERROR, "TAO (%P|%t) - UIOP_Connector [%d]::make_connection, " "could not register the transport " "in the reactor.\n", transport->id ())); return 0; } svc_handler_auto_ptr.release (); return transport; }
TAO_Transport * TAO::IIOP_SSL_Connector::make_connection ( TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *max_wait_time) { TAO_IIOP_Endpoint *iiop_endpoint = dynamic_cast<TAO_IIOP_Endpoint *> (desc.endpoint ()); if (iiop_endpoint == 0) return 0; const ACE_INET_Addr &remote_address = iiop_endpoint->object_addr (); if (TAO_debug_level > 4) ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) IIOP_SSL_Connector::connect ") ACE_TEXT ("making a new connection\n"))); // Get the right synch options ACE_Synch_Options synch_options; this->active_connect_strategy_->synch_options (max_wait_time, synch_options); // If we don't need to block for a transport just set the timeout to // be zero. ACE_Time_Value tmp_zero (ACE_Time_Value::zero); if (!r->blocked_connect ()) { synch_options.timeout (ACE_Time_Value::zero); max_wait_time = &tmp_zero; } IIOP_SSL_Connection_Handler *svc_handler = 0; // Connect. int result = this->base_connector_.connect (svc_handler, remote_address, synch_options); // Make sure that we always do a remove_reference ACE_Event_Handler_var svc_handler_auto_ptr (svc_handler); TAO_Transport *transport = svc_handler->transport (); if (result == -1) { // No immediate result, wait for completion if (errno == EWOULDBLOCK) { // Try to wait until connection completion. Incase we block, then we // get a connected transport or not. In case of non block we get // a connected or not connected transport if (!this->wait_for_connection_completion (r, desc, transport, max_wait_time)) { if (TAO_debug_level > 2) ORBSVCS_ERROR ((LM_ERROR, "TAO (%P|%t) - IIOP_SSL_Connector::" "make_connection, " "wait for completion failed\n")); } } else { // Transport is not usable transport = 0; } } // In case of errors transport is zero if (transport == 0) { // Give users a clue to the problem. if (TAO_debug_level) { ORBSVCS_DEBUG ((LM_ERROR, "TAO (%P|%t) - IIOP_SSL_Connector::make_connection, " "connection to <%s:%d> failed (%p)\n", iiop_endpoint->host (), iiop_endpoint->port (), "errno")); } return 0; } if (svc_handler->keep_waiting (this->orb_core ()->leader_follower ())) { svc_handler->connection_pending (); } // At this point, the connection has be successfully connected. // #REFCOUNT# is one. if (TAO_debug_level > 2) ORBSVCS_DEBUG ((LM_DEBUG, "TAO (%P|%t) - IIOP_SSL_Connector::make_connection, " "new connection to <%s:%d> on Transport[%d]\n", iiop_endpoint->host (), iiop_endpoint->port (), svc_handler->peer ().get_handle ())); // Add the handler to Cache int retval = this->orb_core ()->lane_resources ().transport_cache ().cache_transport ( &desc, transport); // Failure in adding to cache. if (retval == -1) { // Close the handler. svc_handler->close (); if (TAO_debug_level > 0) { ORBSVCS_ERROR ((LM_ERROR, "TAO (%P|%t) - IIOP_SSL_Connector::make_connection, " "could not add the new connection to cache\n")); } return 0; } if (transport->is_connected () && transport->wait_strategy ()->register_handler () != 0) { // Registration failures. // Purge from the connection cache, if we are not in the cache, this // just does nothing. (void) transport->purge_entry (); // Close the handler. (void) transport->close_connection (); if (TAO_debug_level > 0) ORBSVCS_ERROR ((LM_ERROR, "TAO (%P|%t) - IIOP_SSL_Connector [%d]::make_connection, " "could not register the transport " "in the reactor.\n", transport->id ())); return 0; } svc_handler_auto_ptr.release (); return transport; }
TAO_Transport * TAO_SHMIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout) { if (TAO_debug_level > 0) TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Connector::make_connection, ") ACE_TEXT ("looking for SHMIOP connection.\n"))); TAO_SHMIOP_Endpoint *shmiop_endpoint = this->remote_endpoint (desc.endpoint ()); if (shmiop_endpoint == 0) return 0; const ACE_INET_Addr &remote_address = shmiop_endpoint->object_addr (); if (TAO_debug_level > 2) TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - SHMIOP_Connector::make_connection, " "making a new connection to <%C:%d>\n", shmiop_endpoint->host (), shmiop_endpoint->port ())); // Get the right synch options ACE_Synch_Options synch_options; this->active_connect_strategy_->synch_options (timeout, synch_options); TAO_SHMIOP_Connection_Handler *svc_handler = 0; // Connect. int result = this->base_connector_.connect (svc_handler, remote_address, synch_options); // Make sure that we always do a remove_reference ACE_Event_Handler_var svc_handler_auto_ptr (svc_handler); // In case of errors. if (result == -1) { // Give users a clue to the problem. if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - SHMIOP_Connector::make_connection, ") ACE_TEXT ("connection to <%C:%u> failed (%p)\n"), shmiop_endpoint->host (), shmiop_endpoint->port (), ACE_TEXT ("errno"))); } return 0; } if (svc_handler->keep_waiting ()) { svc_handler->connection_pending (); } if (svc_handler->error_detected ()) { svc_handler->cancel_pending_connection (); } TAO_Transport *transport = svc_handler->transport (); // At this point, the connection has be successfully connected. // #REFCOUNT# is one. if (TAO_debug_level > 2) TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - SHMIOP_Connector::make_connection, " "new %C connection to <%C:%d> on Transport[%d]\n", transport->is_connected() ? "connected" : "not connected", shmiop_endpoint->host (), shmiop_endpoint->port (), svc_handler->peer ().get_handle ())); // Add the handler to Cache int retval = this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc, transport); // Failure in adding to cache. if (retval == -1) { // Close the handler. svc_handler->close (); if (TAO_debug_level > 0) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT("TAO (%P|%t) - SHMIOP_Connector::make_connection, ") ACE_TEXT("could not add the new connection to cache\n"))); } return 0; } if (svc_handler->error_detected ()) { svc_handler->cancel_pending_connection (); transport->purge_entry(); return 0; } if (transport->is_connected () && transport->wait_strategy ()->register_handler () != 0) { // Registration failures. // Purge from the connection cache, if we are not in the cache, this // just does nothing. (void) transport->purge_entry (); // Close the handler. (void) transport->close_connection (); if (TAO_debug_level > 0) TAOLIB_ERROR ((LM_ERROR, "TAO (%P|%t) - SHMIOP_Connector [%d]::make_connection, " "could not register the transport in the reactor.\n", transport->id ())); return 0; } svc_handler_auto_ptr.release (); return transport; }
void TAO_LFU_Connection_Purging_Strategy::update_item (TAO_Transport& transport) { transport.purging_order (transport.purging_order () + 1); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "test"); if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = orb->string_to_object(ior); if (CORBA::is_nil (tmp.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Invalid IOR.\n") ,1); } { // Set the Synch Scopes CORBA::Any scope_as_any; if (synch_none == true) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying SYNC_NONE.\n")); scope_as_any <<= Messaging::SYNC_NONE; } else if (synch_delayed == true) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying SYNC_DELAYED_BUFFERING.\n")); scope_as_any <<= TAO::SYNC_DELAYED_BUFFERING; } CORBA::PolicyList policies (1); policies.length (1); policies[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, scope_as_any); if (level_thread == true) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying Synch Scope at thread level.\n")); CORBA::Object_var object = orb->resolve_initial_references ("PolicyCurrent"); CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (object.in ()); policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); } else if (level_orb == true) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying Synch Scope at orb level.\n")); CORBA::Object_var obj = orb->resolve_initial_references("ORBPolicyManager"); CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow(obj.in()); policy_manager->set_policy_overrides (policies, CORBA::ADD_OVERRIDE); } else if (level_obj == true) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) - Applying Synch Scope at Object level.\n")); tmp = tmp->_set_policy_overrides (policies, CORBA::SET_OVERRIDE); } policies[0]->destroy (); } Test::Hello_var hello = Test::Hello::_narrow(tmp.in ()); if (CORBA::is_nil (hello.in ())) { ACE_ERROR_RETURN ((LM_ERROR, "Nil Test::Hello reference <%s>\n", ior), 1); } // If a blocking connection is initiated in the next step // the test will get an exception indicating test failure. // Be sure you IOR is for the localhost endpoint, else // grab a book and wait around for timeout. hello->get_string (); TAO::Transport_Cache_Manager &tcm = hello->orb_core ()->lane_resources ().transport_cache (); TAO_Base_Transport_Property desc (hello->_stubobj ()->profile_in_use ()->endpoint ()); if (tcm.current_size() == 0) { ACE_ERROR_RETURN ((LM_ERROR, "The Transport Cache shouldn't be empty here.\n"), 1); } size_t busy_count = 0; TAO_Transport *transport = 0; TAO::Transport_Cache_Manager::Find_Result find_result = tcm.find_transport (&desc, transport, busy_count); // We don't need this transport any more. Release the ownership. transport->remove_reference (); switch (find_result){ case TAO::Transport_Cache_Manager::CACHE_FOUND_NONE: { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("Expected to find a transport in the cache.\n") ),1); } case TAO::Transport_Cache_Manager::CACHE_FOUND_CONNECTING: { ACE_DEBUG (( LM_DEBUG, ACE_TEXT ("Transport Cache contains connecting entry as expected.\n") )); break; // that's what we expected } case TAO::Transport_Cache_Manager::CACHE_FOUND_BUSY: { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("Cached Transport is busy. Should not happen because there's no server.\n") ),1); } case TAO::Transport_Cache_Manager::CACHE_FOUND_AVAILABLE: { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("Cached Transport is available. Should not happen because there's no server.\n") ),1); } default: { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT("Transport_Cache::find returned unknown status.\n") ),1); } } orb->destroy (); } catch (const CORBA::Exception &ex) { ACE_ERROR ((LM_ERROR, "ERROR: Exception caught: %s\"%s\"\n" , ex._name(), ex._rep_id ())); return 1; } return 0; }