From b0c7f5bc2d24d2aa4ff3c730debeed564938db38 Mon Sep 17 00:00:00 2001 From: bala Date: Fri, 15 Dec 2000 23:00:46 +0000 Subject: *** empty log message *** --- TAO/tao/ClientRequestInfo.cpp | 302 +++++++++++++++++++++------ TAO/tao/ClientRequestInfo.h | 74 ++++--- TAO/tao/Connection_Cache_Manager.cpp | 1 - TAO/tao/Connection_Handler.cpp | 12 ++ TAO/tao/Connection_Handler.h | 3 + TAO/tao/GIOP_Message_Generator_Parser_12.cpp | 190 ++++++++--------- TAO/tao/IIOP_Connection_Handler.cpp | 12 +- TAO/tao/IIOP_Connector.cpp | 2 +- TAO/tao/IIOP_Transport.cpp | 2 +- TAO/tao/PortableInterceptor.h | 7 +- TAO/tao/PortableInterceptor.i | 38 +++- TAO/tao/PortableServer/ServerRequestInfo.cpp | 231 +++++++++++++++----- TAO/tao/PortableServer/ServerRequestInfo.h | 2 +- 13 files changed, 621 insertions(+), 255 deletions(-) diff --git a/TAO/tao/ClientRequestInfo.cpp b/TAO/tao/ClientRequestInfo.cpp index 8913835bbe5..f6ef408dafb 100644 --- a/TAO/tao/ClientRequestInfo.cpp +++ b/TAO/tao/ClientRequestInfo.cpp @@ -3,18 +3,28 @@ // $Id$ #include "ClientRequestInfo.h" +#include "Stub.h" +#include "Tagged_Components.h" -ACE_RCSID(tao, ClientRequestInfo, "$Id$") +ACE_RCSID (tao, ClientRequestInfo, "$Id$") + +#if TAO_HAS_INTERCEPTORS == 1 + +# if !defined (__ACE_INLINE__) +# include "ClientRequestInfo.inl" +# endif /* !__ACE_INLINE__ */ -#if (TAO_HAS_INTERCEPTORS == 1) TAO_ClientRequestInfo::TAO_ClientRequestInfo (const char * operation, IOP::ServiceContextList - &service_context_list, + &service_context_list, CORBA::Object_ptr target) : operation_ (operation), service_context_list_ (service_context_list), - target_ (CORBA_Object::_duplicate (target)) + target_ (CORBA::Object::_duplicate (target)), + caught_exception_ (0), + response_expected_ (1), + reply_status_ (-1) { } @@ -22,6 +32,15 @@ CORBA::Object_ptr TAO_ClientRequestInfo::target (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { +// if (this->reply_status_ == +// PortableInterceptor::LOCATION_FORWARD_PERMANENT) +// { +// // TAO_GIOP_Invocation::forward_reference() already duplicates +// // the reference before returning it so there is no need to +// // duplicate it here. +// return this->invocation_->forward_reference (); +// } + return CORBA::Object::_duplicate (this->target_.in ()); } @@ -29,27 +48,72 @@ CORBA::Object_ptr TAO_ClientRequestInfo::effective_target (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - return CORBA::Object::_nil (); +// if (this->reply_status_ == PortableInterceptor::LOCATION_FORWARD +// || this->reply_status_ == +// PortableInterceptor::LOCATION_FORWARD_PERMANENT) +// { +// // TAO_GIOP_Invocation::forward_reference() already duplicates +// // the reference before returning it so there is no need to +// // duplicate it here. +// return this->invocation_->forward_reference (); +// } + + return CORBA::Object::_duplicate (this->target_.in ()); } IOP::TaggedProfile * -TAO_ClientRequestInfo::effective_profile (CORBA::Environment &) +TAO_ClientRequestInfo::effective_profile (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + IOP::TaggedProfile *tagged_profile = 0; + ACE_NEW_THROW_EX (tagged_profile, + IOP::TaggedProfile, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + IOP::TaggedProfile_var safe_tagged_profile = tagged_profile; + + IOP::TaggedProfile &ep = + this->target_->_stubobj ()->profile_in_use ()->create_tagged_profile (); + + tagged_profile->tag = ep.tag; + tagged_profile->profile_data = ep.profile_data; // Deep copy + + return safe_tagged_profile._retn (); } // Use at own risk. There is no way currently of extracting an // exception from an Any. This method is in place just to be compliant // with the spec. CORBA::Any * -TAO_ClientRequestInfo::received_exception (CORBA::Environment &) +TAO_ClientRequestInfo::received_exception (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - // The spec says that if it is a user exception which can't be inserted - // then the UNKNOWN exception needs to be thrown with minor code TBD_U. - this->any_exception_ <<= *this->caught_exception_; - return &this->any_exception_; + // The spec says that if it is a user exception which can't be + // inserted then the UNKNOWN exception needs to be thrown with minor + // code TBD_U. + + CORBA::Any * temp = 0; + + ACE_NEW_THROW_EX (temp, + CORBA::Any, + CORBA::NO_MEMORY ( + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + CORBA::Any_var caught_exception = temp; + + if (this->caught_exception_ != 0) + *temp <<= *(this->caught_exception_); + + return caught_exception._retn (); } // = TAO specific method done since there currently is no simple way @@ -69,11 +133,37 @@ TAO_ClientRequestInfo::received_exception_id (CORBA::Environment &) } IOP::TaggedComponent * -TAO_ClientRequestInfo::get_effective_component (IOP::ComponentId, - CORBA::Environment &) +TAO_ClientRequestInfo::get_effective_component ( + IOP::ComponentId id, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + IOP::TaggedComponent *tagged_component = 0; + ACE_NEW_THROW_EX (tagged_component, + IOP::TaggedComponent, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + IOP::TaggedComponent_var safe_tagged_component = tagged_component; + + const TAO_Tagged_Components &ecs = + this->target_->_stubobj ()->profile_in_use ()->tagged_components (); + + tagged_component->tag = id; + + if (!ecs.get_component (*tagged_component)) + ACE_THROW_RETURN (CORBA::BAD_PARAM ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), // @@ Need minor code from PI spec! + CORBA::COMPLETED_NO), + 0); + + return safe_tagged_component._retn (); } CORBA::Policy_ptr @@ -81,6 +171,7 @@ TAO_ClientRequestInfo::get_request_policy (CORBA::PolicyType type, CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { + // @@ Do we need to look anywhere else for the request policies? return this->target_->_get_policy (type, ACE_TRY_ENV); } @@ -88,15 +179,34 @@ TAO_ClientRequestInfo::get_request_policy (CORBA::PolicyType type, void TAO_ClientRequestInfo::add_request_service_context ( const IOP::ServiceContext & service_context, - CORBA::Boolean, - CORBA::Environment &) + CORBA::Boolean replace, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { // Copy the service context into the list. - CORBA::ULong length = this->service_context_list_.length (); - this->service_context_list_.length (length + 1); - - this->service_context_list_[length] = service_context; + CORBA::ULong len = this->service_context_list_.length (); + + // First check if a service context with the same ID exists. + for (CORBA::ULong i = 0; i < len; ++i) + { + if (this->service_context_list_[i].context_id == + service_context.context_id) + { + if (replace) + { + this->service_context_list_[i] = service_context; + return; + } + else + // @@ Need the minor code once it becomes available. + ACE_THROW (CORBA::BAD_INV_ORDER ()); + } + } + + // No service context with the given ID exists so add one. + this->service_context_list_.length (len + 1); + + this->service_context_list_[len] = service_context; } CORBA::ULong @@ -108,17 +218,16 @@ TAO_ClientRequestInfo::request_id (CORBA::Environment &) char * TAO_ClientRequestInfo::operation (CORBA::Environment &) - ACE_THROW_SPEC ((CORBA::SystemException)) + ACE_THROW_SPEC ((CORBA::SystemException)) { return CORBA::string_dup (this->operation_); - } Dynamic::ParameterList * TAO_ClientRequestInfo::arguments (CORBA::Environment &) - ACE_THROW_SPEC ((CORBA::SystemException)) + ACE_THROW_SPEC ((CORBA::SystemException)) { - return &this->parameter_list_; + return &this->parameter_list_; } Dynamic::ExceptionList * @@ -132,14 +241,14 @@ Dynamic::ContextList * TAO_ClientRequestInfo::contexts (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - return &this->context_list_; + return &this->context_list_; } Dynamic::RequestContext * TAO_ClientRequestInfo::operation_context (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - return &this->request_context_; + return &this->request_context_; } CORBA::Any * @@ -153,85 +262,146 @@ CORBA::Boolean TAO_ClientRequestInfo::response_expected (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + return this->response_expected_; } -# if (TAO_HAS_CORBA_MESSAGING == 1) +# if TAO_HAS_CORBA_MESSAGING == 1 CORBA::Short TAO_ClientRequestInfo::sync_scope (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; +// TAO_GIOP_Oneway_Invocation *inv = +// ACE_dynamic_cast (TAO_GIOP_Oneway_Invocation *, +// this->invocation_); + +// // The response_expected_ check is a precautionary measure for +// // platforms that do not support RTTI, i.e. where the dynamic_cast +// // above would incorrectly work. If the response_expected flag is +// // not equal to zero then it is fairly safe to assume that the +// // invocation is not a one-way, meaning that the sync_scope() method +// // is not available. +// if (inv != 0 && this->response_expected_ == 0) +// return inv->sync_scope (); + +// ACE_THROW_RETURN (CORBA::BAD_INV_ORDER (), -1); + + return 0; } -#endif /* TAO_HAS_CORBA_MESSAGING */ +#endif /* TAO_HAS_CORBA_MESSAGING == 1 */ PortableInterceptor::ReplyStatus -TAO_ClientRequestInfo::reply_status (CORBA::Environment &) +TAO_ClientRequestInfo::reply_status (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + if (this->reply_status_ == -1) + // A reply hasn't been received yet. + ACE_THROW_RETURN (CORBA::BAD_INV_ORDER (), -1); + + return this->reply_status_; } CORBA::Object_ptr -TAO_ClientRequestInfo::forward_reference (CORBA::Environment &) +TAO_ClientRequestInfo::forward_reference (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + if (this->reply_status_ != PortableInterceptor::LOCATION_FORWARD + || this->reply_status_ != + PortableInterceptor::LOCATION_FORWARD_PERMANENT) + ACE_THROW_RETURN (CORBA::BAD_INV_ORDER (), + CORBA::Object::_nil ()); + +// // TAO_GIOP_Invocation::forward_reference() already duplicates the +// // reference before returning it so there is no need to duplicate it +// // here. +// return this->invocation_->forward_reference (); + + return CORBA::Object::_nil (); } CORBA::Any * TAO_ClientRequestInfo::get_slot (PortableInterceptor::SlotId, - CORBA::Environment &) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::InvalidSlot)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } IOP::ServiceContext * -TAO_ClientRequestInfo::get_request_service_context (IOP::ServiceId id, - CORBA::Environment &) +TAO_ClientRequestInfo::get_request_service_context ( + IOP::ServiceId id, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - for (CORBA::ULong size = 0; - size < this->service_context_list_.length (); - ++size) - if (this->service_context_list_[size].context_id == id) + CORBA::ULong len = this->service_context_list_.length (); + + for (CORBA::ULong i = 0; i < len; ++i) + if (this->service_context_list_[i].context_id == id) { - return &(this->service_context_list_[size]); + IOP::ServiceContext *service_context = 0; + ACE_NEW_THROW_EX (service_context, + IOP::ServiceContext, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + IOP::ServiceContext_var safe_service_context = service_context; + + (*service_context) = this->service_context_list_[i]; + + return safe_service_context._retn (); } - return 0; + ACE_THROW_RETURN (CORBA::BAD_PARAM ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), // @@ Need minor code from PI spec! + CORBA::COMPLETED_NO), + 0); } IOP::ServiceContext * -TAO_ClientRequestInfo::get_reply_service_context (IOP::ServiceId id, - CORBA::Environment &) +TAO_ClientRequestInfo::get_reply_service_context ( + IOP::ServiceId id, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - for (CORBA::ULong size = 0; - size < this->service_context_list_.length (); - ++size) - if (this->service_context_list_[size].context_id == id) + CORBA::ULong len = this->service_context_list_.length (); + + for (CORBA::ULong i = 0; i < len; ++i) + if (this->service_context_list_[i].context_id == id) { - // Will it will get safely destroyed at the - // TAO_Client side when the service context gets back. - return &this->service_context_list_[size]; - } + IOP::ServiceContext *service_context = 0; + ACE_NEW_THROW_EX (service_context, + IOP::ServiceContext, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); - return 0; -} + IOP::ServiceContext_var safe_service_context = service_context; -void -TAO_ClientRequestInfo::exception (CORBA::Exception *exception) -{ - this->caught_exception_ = exception; -} + (*service_context) = this->service_context_list_[i]; -void -TAO_ClientRequestInfo::request_id (CORBA::ULong request_id) -{ - this->request_id_ = request_id; + return safe_service_context._retn (); + } + + ACE_THROW_RETURN (CORBA::BAD_PARAM ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), // @@ Need minor code from PI spec! + CORBA::COMPLETED_NO), + 0); } #endif /* TAO_HAS_INTERCEPTORS == 1 */ diff --git a/TAO/tao/ClientRequestInfo.h b/TAO/tao/ClientRequestInfo.h index 806dd300dcc..ad83903425d 100644 --- a/TAO/tao/ClientRequestInfo.h +++ b/TAO/tao/ClientRequestInfo.h @@ -1,32 +1,25 @@ // -*- C++ -*- -// -// $Id$ - -//======================================================================== -// -// = LIBRARY -// TAO -// -// = FILENAME -// ClientRequestInfo.h -// -// = DESCRIPTION -// This is the implementation of the -// PortableInterceptor::ClientRequestInfo interface. -// -// = AUTHOR -// Kirthika Parameswaran -// Ossama Othman -// -//========================================================================= +//============================================================================= +/** + * @file ClientRequestInfo.h + * + * $Id$ + * + * This is the implementation of the + * PortableInterceptor::ClientRequestInfo interface. + * + * @author Kirthika Parameswaran + * @author Ossama Othman + */ +//============================================================================= #ifndef TAO_CLIENT_REQUEST_INFO_H #define TAO_CLIENT_REQUEST_INFO_H #include "ace/pre.h" -#include "tao/corbafwd.h" +#include "corbafwd.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once @@ -41,10 +34,10 @@ #if (TAO_HAS_INTERCEPTORS == 1) -#include "tao/PortableInterceptorC.h" -#include "tao/LocalObject.h" -#include "tao/StringSeqC.h" - +#include "PortableInterceptorC.h" +#include "LocalObject.h" +#include "StringSeqC.h" +#include "Invocation.h" class TAO_Export TAO_ClientRequestInfo : public virtual PortableInterceptor::ClientRequestInfo, @@ -87,11 +80,11 @@ public: CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)) ; -# if (TAO_HAS_CORBA_MESSAGING == 1) +#if TAO_HAS_CORBA_MESSAGING == 1 virtual CORBA::Short sync_scope ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); -#endif /* TAO_HAS_CORBA_MESSAGING */ +#endif /* TAO_HAS_CORBA_MESSAGING == 1 */ virtual PortableInterceptor::ReplyStatus reply_status ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) @@ -129,17 +122,17 @@ public: CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); + /// This method causes problem since there is no trivial way to + /// extract the exception from the Any. virtual CORBA::Any * received_exception ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // This method causes problem since there is no trivial way to - // extract the exception from the Any. + /// Note: This is TAO specific and was done to combat the previous + /// problem to some extent. virtual CORBA::Exception * _received_exception ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Note: This is TAO specific and was done to combat the previous - // problem to some extent. virtual char * received_exception_id ( CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ()) @@ -162,20 +155,27 @@ public: ACE_THROW_SPEC ((CORBA::SystemException)); protected: + /// Change the exception status. void exception (CORBA::Exception *exception); - // Change the exception status. void request_id (CORBA::ULong request_id); // Update the request id. + /// Set the flag that states whether or not a response is expected. + /// For example, no response is expected in a one-way operation. + void response_expected (CORBA::Boolean flag); + + /// Set the status of the received reply. + void reply_status (int invoke_status); + protected: + CORBA::ULong request_id_; const char * operation_; Dynamic::ParameterList parameter_list_; Dynamic::ExceptionList exception_list_; Dynamic::ContextList context_list_; Dynamic::RequestContext request_context_; - CORBA::Object_var forward_reference_; // Needed to ensure no copy anywhere. IOP::ServiceContextList &service_context_list_; @@ -183,10 +183,16 @@ protected: CORBA::Any result_val_; CORBA::Object_var target_; CORBA::Object_var effective_target_; - CORBA::Any any_exception_; CORBA::Exception *caught_exception_; + + CORBA::Boolean response_expected_; + PortableInterceptor::ReplyStatus reply_status_; }; +# if defined (__ACE_INLINE__) +# include "ClientRequestInfo.inl" +# endif /* __ACE_INLINE__ */ + #endif /* TAO_HAS_INTERCEPTORS == 1 */ #if defined(_MSC_VER) && (_MSC_VER >= 1200) diff --git a/TAO/tao/Connection_Cache_Manager.cpp b/TAO/tao/Connection_Cache_Manager.cpp index fddc6140112..2283ff38694 100644 --- a/TAO/tao/Connection_Cache_Manager.cpp +++ b/TAO/tao/Connection_Cache_Manager.cpp @@ -200,7 +200,6 @@ TAO_Connection_Cache_Manager::make_idle_i (HASH_MAP_ENTRY *&entry) new_entry); if (retval == 0) { - new_entry->int_id_. recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE); diff --git a/TAO/tao/Connection_Handler.cpp b/TAO/tao/Connection_Handler.cpp index e25845bca72..2702a2ff655 100644 --- a/TAO/tao/Connection_Handler.cpp +++ b/TAO/tao/Connection_Handler.cpp @@ -53,6 +53,18 @@ TAO_Connection_Handler::make_idle (void) this->orb_core_->connection_cache ().make_idle (this->cache_map_entry_); } +int +TAO_Connection_Handler::recache_handler (TAO_Connection_Descriptor_Interface *desc) +{ + // First purge our entry + this->orb_core_->connection_cache ().purge_entry (this->cache_map_entry_); + + // Then add ourselves to the cache + return this->orb_core_->connection_cache ().cache_handler (desc, + this); +} + + int TAO_Connection_Handler::set_socket_option (ACE_SOCK &sock, diff --git a/TAO/tao/Connection_Handler.h b/TAO/tao/Connection_Handler.h index 0488a8b5c7e..e5a0f03f432 100644 --- a/TAO/tao/Connection_Handler.h +++ b/TAO/tao/Connection_Handler.h @@ -80,6 +80,9 @@ public: int make_idle (void); // Make ourselves ready for use + int recache_handler (TAO_Connection_Descriptor_Interface *); + // recache ourselves in the cache + void incr_ref_count (void); // Increment the reference count diff --git a/TAO/tao/GIOP_Message_Generator_Parser_12.cpp b/TAO/tao/GIOP_Message_Generator_Parser_12.cpp index ad83299eb75..a341edefd31 100644 --- a/TAO/tao/GIOP_Message_Generator_Parser_12.cpp +++ b/TAO/tao/GIOP_Message_Generator_Parser_12.cpp @@ -38,60 +38,60 @@ TAO_GIOP_Message_Generator_Parser_12::write_request_header ( // First the request id msg << opdetails.request_id (); - const CORBA::Octet response_flags = opdetails.response_flags (); - - // Here are the Octet values for different policies - // '00000000' for SYNC_NONE - // '00000000' for SYNC_WITH_TRANSPORT - // '00000010' for SYNC_WITH_SERVER - // '00000011' for SYNC_WITH_TARGET - // '00000011' for regular two ways, but if they are invoked via a + const CORBA::Octet response_flags = opdetails.response_flags (); + + // Here are the Octet values for different policies + // '00000000' for SYNC_NONE + // '00000000' for SYNC_WITH_TRANSPORT + // '00000010' for SYNC_WITH_SERVER + // '00000011' for SYNC_WITH_TARGET + // '00000011' for regular two ways, but if they are invoked via a // DII with INV_NO_RESPONSE flag set then we need to send '00000001' // - // We have not implemented the policy INV_NO_RESPONSE for DII. - if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) - msg << CORBA::Any::from_octet (3); - // Second the response flags - // Sync scope - ignored by server if request is not oneway. + // We have not implemented the policy INV_NO_RESPONSE for DII. + if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) + msg << CORBA::Any::from_octet (3); + // Second the response flags + // Sync scope - ignored by server if request is not oneway. else if (response_flags == CORBA::Octet (TAO::SYNC_NONE) || - response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) || - response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) || - response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING)) + response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) || + response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) || + response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING)) // No response required. - msg << CORBA::Any::from_octet (0); + msg << CORBA::Any::from_octet (0); else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_SERVER)) - // Return before dispatching to the servant - msg << CORBA::Any::from_octet (1); + // Return before dispatching to the servant + msg << CORBA::Any::from_octet (1); else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_TARGET)) - // Return after dispatching servant. - msg << CORBA::Any::from_octet (3); + // Return after dispatching servant. + msg << CORBA::Any::from_octet (3); else - // Until more flags are defined by the OMG. + // Until more flags are defined by the OMG. return 0; // The reserved field CORBA::Octet reserved[3] = {0, 0, 0}; - msg.write_octet_array (reserved, 3); + msg.write_octet_array (reserved, 3); if (this->marshall_target_spec (spec, - msg) == 0) + msg) == 0) return 0; // Write the operation name msg.write_string (opdetails.opname_len (), - opdetails.opname ()); + opdetails.opname ()); // Write the service context list - msg << opdetails.service_info (); + msg << opdetails.service_info (); - // We align the pointer only if the operation has arguments. + // We align the pointer only if the operation has arguments. if (opdetails.argument_flag ()) { if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) - return 0; + return 0; } return 1; @@ -101,7 +101,7 @@ TAO_GIOP_Message_Generator_Parser_12::write_request_header ( int TAO_GIOP_Message_Generator_Parser_12::write_locate_request_header ( CORBA::ULong request_id, - TAO_Target_Specification &spec, + TAO_Target_Specification &spec, TAO_OutputCDR &msg ) { @@ -110,12 +110,12 @@ TAO_GIOP_Message_Generator_Parser_12::write_locate_request_header ( // Write the target address if (this->marshall_target_spec (spec, - msg) == 0) + msg) == 0) return 0; // I dont think we need to align the pointer to an 8 byte boundary // here. - // We need to align the pointer + // We need to align the pointer // if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) // return 0; @@ -349,6 +349,8 @@ TAO_GIOP_Message_Generator_Parser_12::parse_request_header ( input >> service_info; + // Check an process if BiDir contexts are available + this->check_bidirectional_context (request); if (input.length () > 0) { @@ -498,77 +500,77 @@ TAO_GIOP_Message_Generator_Parser_12::marshall_target_spec ( { case TAO_Target_Specification::Key_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::KeyAddr; - - // Get the object key - const TAO_ObjectKey *key = spec.object_key (); - if (key) - { - // Marshall in the object key - msg << *key; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::KeyAddr; + + // Get the object key + const TAO_ObjectKey *key = spec.object_key (); + if (key) + { + // Marshall in the object key + msg << *key; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } case TAO_Target_Specification::Profile_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::ProfileAddr; - - // Get the profile - const IOP::TaggedProfile *pfile = spec.profile (); - - if (pfile) - { - // Marshall in the object key - msg << *pfile; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::ProfileAddr; + + // Get the profile + const IOP::TaggedProfile *pfile = spec.profile (); + + if (pfile) + { + // Marshall in the object key + msg << *pfile; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } case TAO_Target_Specification::Reference_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::ReferenceAddr; - - // Get the IOR - IOP::IOR *ior; - CORBA::ULong index = spec.iop_ior (ior); - - if (ior) - { - // This is a struct IORAddressingInfo. So, marshall each - // member of the struct one after another in the order - // defined. - msg << index; - msg << *ior; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::ReferenceAddr; + + // Get the IOR + IOP::IOR *ior; + CORBA::ULong index = spec.iop_ior (ior); + + if (ior) + { + // This is a struct IORAddressingInfo. So, marshall each + // member of the struct one after another in the order + // defined. + msg << index; + msg << *ior; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } default: if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); return 0; } @@ -612,8 +614,6 @@ TAO_GIOP_Message_Generator_Parser_12::process_bidir_context ( context.context_data.get_buffer ()), context.context_data.length ()); - - return transport->tear_listen_point_list (cdr); } diff --git a/TAO/tao/IIOP_Connection_Handler.cpp b/TAO/tao/IIOP_Connection_Handler.cpp index 5186e705a1a..5c4d950c15f 100644 --- a/TAO/tao/IIOP_Connection_Handler.cpp +++ b/TAO/tao/IIOP_Connection_Handler.cpp @@ -265,12 +265,13 @@ TAO_IIOP_Connection_Handler::process_listen_point_list ( // Get the size of the list CORBA::ULong len = listen_list.length (); - for (CORBA::ULong i = 0; i <= len; ++ i) + for (CORBA::ULong i = 0; i < len; ++ i) { IIOP::ListenPoint listen_point = listen_list[i]; ACE_INET_Addr addr (listen_point.port, listen_point.host.in ()); + // Construct an IIOP_Endpoint object TAO_IIOP_Endpoint endpoint (addr, 0); @@ -281,11 +282,14 @@ TAO_IIOP_Connection_Handler::process_listen_point_list ( // Mark the connection as bidirectional prop.set_bidir_flag (1); - // Add the handler to Cache - int retval = this->orb_core ()->connection_cache ().cache_handler (&prop, - this); + // The property for this handler has changed. Recache the + // handler with this property + int retval = this->recache_handler (&prop); if (retval == -1) return retval; + + // Make the handler idle and ready for use + this->make_idle (); } return 0; diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index 353fb469af5..d4c01f1ff41 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -114,7 +114,7 @@ TAO_IIOP_Connector::connect (TAO_Connection_Descriptor_Interface *desc, // any if (this->orb_core ()->bidir_giop_policy ()) { - desc->set_bidir_flag (1); + //desc->set_bidir_flag (1); } // Check the Cache first for connections diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp index 71552b80441..5d0e7c3c1ad 100644 --- a/TAO/tao/IIOP_Transport.cpp +++ b/TAO/tao/IIOP_Transport.cpp @@ -543,7 +543,7 @@ TAO_IIOP_Transport::get_listen_point ( -1); } - cout << "Amba sambavi " <stack_size_; + --this->stack_size_; this->interceptors_[this->stack_size_]->receive_exception ( ri @@ -102,6 +102,38 @@ receive_exception (PortableInterceptor::ClientRequestInfo_ptr ri, ACE_UNUSED_ARG (ACE_TRY_ENV); } +ACE_INLINE void +TAO_ClientRequestInterceptor_Adapter:: +receive_other (PortableInterceptor::ClientRequestInfo_ptr ri, + CORBA::Environment &ACE_TRY_ENV) +{ + // This is an "ending" interception point so we only process the + // interceptors pushed on to the flow stack. + + // Notice that the interceptors are processed in the opposite order + // they were pushed onto the stack since this is an "ending" + // interception point. + + // Unwind the stack. + size_t len = this->stack_size_; + for (size_t i = 0; i < len; ++i) + { + // Pop the interceptor off of the flow stack before it is + // invoked. This is necessary to prevent an interceptor already + // invoked in this "ending" interception point from being + // invoked in another "ending" interception point. + --this->stack_size_; + + this->interceptors_[this->stack_size_]->receive_other ( + ri + TAO_ENV_ARG_PARAMETER); + ACE_CHECK; + } + + ACE_UNUSED_ARG (ACE_TRY_ENV); + +} + // ------------------------------------------------------------------- ACE_INLINE @@ -170,7 +202,7 @@ send_reply (PortableInterceptor::ServerRequestInfo_ptr ri, // invoked. This is necessary to prevent an interceptor already // invoked in this "ending" interception point from being // invoked in another "ending" interception point. - --this->stack_size_; + --this->stack_size_; this->interceptors_[this->stack_size_]->send_reply ( ri @@ -201,7 +233,7 @@ send_exception (PortableInterceptor::ServerRequestInfo_ptr ri, // invoked. This is necessary to prevent an interceptor already // invoked in this "ending" interception point from being // invoked in another "ending" interception point. - --this->stack_size_; + --this->stack_size_; this->interceptors_[this->stack_size_]->send_exception ( ri diff --git a/TAO/tao/PortableServer/ServerRequestInfo.cpp b/TAO/tao/PortableServer/ServerRequestInfo.cpp index 7dee8bb6b19..d14e21fbe9e 100644 --- a/TAO/tao/PortableServer/ServerRequestInfo.cpp +++ b/TAO/tao/PortableServer/ServerRequestInfo.cpp @@ -12,7 +12,9 @@ TAO_ServerRequestInfo::TAO_ServerRequestInfo ( const char * operation, IOP::ServiceContextList &service_context_list) : operation_ (operation), - service_context_list_ (service_context_list) + service_context_list_ (service_context_list), + caught_exception_ (0), + reply_status_ (-1) { } @@ -66,10 +68,15 @@ TAO_ServerRequestInfo::result (CORBA::Environment &) } CORBA::Boolean -TAO_ServerRequestInfo::response_expected (CORBA::Environment &) +TAO_ServerRequestInfo::response_expected (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } # if TAO_HAS_CORBA_MESSAGING == 1 @@ -82,58 +89,118 @@ TAO_ServerRequestInfo::sync_scope (CORBA::Environment &) #endif /* TAO_HAS_CORBA_MESSAGING */ PortableInterceptor::ReplyStatus -TAO_ServerRequestInfo::reply_status (CORBA::Environment &) +TAO_ServerRequestInfo::reply_status (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + if (this->reply_status_ == -1) + // A reply hasn't been received yet. + ACE_THROW_RETURN (CORBA::BAD_INV_ORDER (), -1); + + return this->reply_status_; } CORBA::Object_ptr -TAO_ServerRequestInfo::forward_reference (CORBA::Environment &) +TAO_ServerRequestInfo::forward_reference (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + if (this->reply_status_ != PortableInterceptor::LOCATION_FORWARD + || this->reply_status_ != + PortableInterceptor::LOCATION_FORWARD_PERMANENT) + ACE_THROW_RETURN (CORBA::BAD_INV_ORDER (), + CORBA::Object::_nil ()); + +// // TAO_GIOP_Invocation::forward_reference() already duplicates the +// // reference before returning it so there is no need to duplicate it +// // here. +// return this->invocation_->forward_reference (); + + return CORBA::Object::_nil (); } CORBA::Any * TAO_ServerRequestInfo::get_slot (PortableInterceptor::SlotId, - CORBA::Environment &) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::InvalidSlot)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } IOP::ServiceContext * -TAO_ServerRequestInfo::get_request_service_context (IOP::ServiceId id, - CORBA::Environment &) +TAO_ServerRequestInfo::get_request_service_context ( + IOP::ServiceId id, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - for (CORBA::ULong size = 0; - size < this->service_context_list_.length (); - ++size) - { - if (this->service_context_list_[size].context_id == id) - return &(this->service_context_list_[size]); - } - - return 0; + CORBA::ULong len = this->service_context_list_.length (); + + for (CORBA::ULong i = 0; i < len; ++i) + if (this->service_context_list_[i].context_id == id) + { + IOP::ServiceContext *service_context = 0; + ACE_NEW_THROW_EX (service_context, + IOP::ServiceContext, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + IOP::ServiceContext_var safe_service_context = service_context; + + (*service_context) = this->service_context_list_[i]; + + return safe_service_context._retn (); + } + + ACE_THROW_RETURN (CORBA::BAD_PARAM ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), // @@ Need minor code from PI spec! + CORBA::COMPLETED_NO), + 0); } IOP::ServiceContext * -TAO_ServerRequestInfo::get_reply_service_context (IOP::ServiceId id, - CORBA::Environment &) +TAO_ServerRequestInfo::get_reply_service_context ( + IOP::ServiceId id, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - for (CORBA::ULong size = 0; - size < this->service_context_list_.length (); - ++size) - { - if (this->service_context_list_[size].context_id == id) - return &this->service_context_list_[size]; - } - - return 0; + CORBA::ULong len = this->service_context_list_.length (); + + for (CORBA::ULong i = 0; i < len; ++i) + if (this->service_context_list_[i].context_id == id) + { + IOP::ServiceContext *service_context = 0; + ACE_NEW_THROW_EX (service_context, + IOP::ServiceContext, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + IOP::ServiceContext_var safe_service_context = service_context; + + (*service_context) = this->service_context_list_[i]; + + return safe_service_context._retn (); + } + + ACE_THROW_RETURN (CORBA::BAD_PARAM ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), // @@ Need minor code from PI spec! + CORBA::COMPLETED_NO), + 0); } @@ -141,13 +208,29 @@ TAO_ServerRequestInfo::get_reply_service_context (IOP::ServiceId id, // exception from an Any. This method is in place just to be compliant // with the spec. CORBA::Any * -TAO_ServerRequestInfo::sending_exception (CORBA::Environment &) +TAO_ServerRequestInfo::sending_exception (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { // The spec says that if it is a user exception which cant be inserted // then the UNKNOWN exception needs to be thrown with minor code TBD_U. - this->any_exception_ <<= *this->caught_exception_; - return &this->any_exception_; + + CORBA::Any * temp = 0; + + ACE_NEW_THROW_EX (temp, + CORBA::Any, + CORBA::NO_MEMORY ( + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOMEM), + CORBA::COMPLETED_NO)); + ACE_CHECK_RETURN (0); + + CORBA::Any_var caught_exception = temp; + + if (this->caught_exception_ != 0) + (*temp) <<= *(this->caught_exception_); + + return caught_exception._retn (); } // = TAO specific method done since there currently is no simple way @@ -160,24 +243,40 @@ TAO_ServerRequestInfo::_sending_exception (CORBA::Environment &) } CORBA::OctetSeq * -TAO_ServerRequestInfo::object_id (CORBA::Environment &) +TAO_ServerRequestInfo::object_id (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } CORBA::OctetSeq * -TAO_ServerRequestInfo::adapter_id (CORBA::Environment &) +TAO_ServerRequestInfo::adapter_id (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } char * -TAO_ServerRequestInfo::target_most_derived_interface (CORBA::Environment &) +TAO_ServerRequestInfo::target_most_derived_interface ( + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } CORBA::Policy_ptr @@ -191,35 +290,71 @@ TAO_ServerRequestInfo::get_server_policy (CORBA::PolicyType, void TAO_ServerRequestInfo::set_slot (PortableInterceptor::SlotId, const CORBA::Any &, - CORBA::Environment &) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException, PortableInterceptor::InvalidSlot)) { + ACE_THROW (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO)); } CORBA::Boolean TAO_ServerRequestInfo::target_is_a (const char *, - CORBA::Environment &) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - return 0; + ACE_THROW_RETURN (CORBA::NO_IMPLEMENT ( + CORBA::SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + ENOTSUP), + CORBA::COMPLETED_NO), + 0); } void TAO_ServerRequestInfo::add_reply_service_context ( const IOP::ServiceContext & service_context, - CORBA::Boolean, - CORBA::Environment &) + CORBA::Boolean replace, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - CORBA::ULong length = this->service_context_list_.length (); - this->service_context_list_.length (length + 1); - service_context_list_[length] = service_context; + // Copy the service context into the list. + CORBA::ULong len = this->service_context_list_.length (); + + // First check if a service context with the same ID exists. + for (CORBA::ULong i = 0; i < len; ++i) + { + if (this->service_context_list_[i].context_id == + service_context.context_id) + { + if (replace) + { + this->service_context_list_[i] = service_context; + return; + } + else + // @@ Need the minor code once it becomes available. + ACE_THROW (CORBA::BAD_INV_ORDER ()); + } + } + + // No service context with the given ID exists so add one. + this->service_context_list_.length (len + 1); + + this->service_context_list_[len] = service_context; } void TAO_ServerRequestInfo::exception (CORBA::Exception *exception) { + if (CORBA::SystemException::_downcast (exception) != 0) + this->reply_status_ = PortableInterceptor::SYSTEM_EXCEPTION; + if (CORBA::UserException::_downcast (exception) != 0) + this->reply_status_ = PortableInterceptor::USER_EXCEPTION; + this->caught_exception_ = exception; } diff --git a/TAO/tao/PortableServer/ServerRequestInfo.h b/TAO/tao/PortableServer/ServerRequestInfo.h index 42736ae95a1..f63cc154b1f 100644 --- a/TAO/tao/PortableServer/ServerRequestInfo.h +++ b/TAO/tao/PortableServer/ServerRequestInfo.h @@ -186,9 +186,9 @@ class TAO_PortableServer_Export TAO_ServerRequestInfo CORBA::Any result_val_; CORBA::OctetSeq_var object_id_; CORBA::OctetSeq_var adapter_id_; - CORBA::Any any_exception_; CORBA::Exception *caught_exception_; + PortableInterceptor::ReplyStatus reply_status_; }; #if defined(_MSC_VER) && (_MSC_VER >= 1200) -- cgit v1.2.1