ChangeLogTag: Sun Nov 26 16:52:50 2000 Balachandran Natarajan <bala@cs.wustl.edu>

4 files changed, 545 insertions, 525 deletions

diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a
index 5d11589dbc5..0433ea24e5c 100644
--- a/TAO/ChangeLogs/ChangeLog-02a
+++ b/TAO/ChangeLogs/ChangeLog-02a
@@ -1,3 +1,15 @@
+Sun Nov 26 16:52:50 2000  Balachandran Natarajan  <bala@cs.wustl.edu>
+
+	* tao/Bind_Dispatcher_Guard.i:
+	* tao/Bind_Dispatcher_Guard.h: Return the reference to the status_
+	  in the status () method. 
+	
+	* tao/Invocation.cpp (invoke_i): If there is an error and if the
+	  connection is closed, we set the status in the
+	  Bind_Dispatcher_Guard to -1. This should fix a problem that
+	  caused the client ORB to dump a core if the server shutsdown
+	  suddenly. 
+
 Sun Nov 26 13:34:40 2000  Carlos O'Ryan  <coryan@uci.edu>
 
         * tao/DynamicAny/DynAny_i.cpp:
diff --git a/TAO/tao/Bind_Dispatcher_Guard.h b/TAO/tao/Bind_Dispatcher_Guard.h
index 0d7ef92e10f..b5cdba4770f 100644
--- a/TAO/tao/Bind_Dispatcher_Guard.h
+++ b/TAO/tao/Bind_Dispatcher_Guard.h
@@ -30,7 +30,7 @@ public:
 
   ~TAO_Bind_Dispatcher_Guard (void);
 
-  int status(void) const;
+  int& status(void);
 
 private:
   int                         status_;
@@ -40,7 +40,7 @@ private:
 };
 
 #if defined (__ACE_INLINE__)
-# include "tao/Bind_Dispatcher_Guard.i"   
+# include "tao/Bind_Dispatcher_Guard.i"
 #endif /* __ACE_INLINE__ */
 
 #include "ace/post.h"
diff --git a/TAO/tao/Bind_Dispatcher_Guard.i b/TAO/tao/Bind_Dispatcher_Guard.i
index 3c7f9dd9b98..f0a5747940f 100644
--- a/TAO/tao/Bind_Dispatcher_Guard.i
+++ b/TAO/tao/Bind_Dispatcher_Guard.i
@@ -40,8 +40,8 @@ TAO_Bind_Dispatcher_Guard::~TAO_Bind_Dispatcher_Guard (void)
 }
 
 
-ACE_INLINE int
-TAO_Bind_Dispatcher_Guard::status (void) const
+ACE_INLINE int &
+TAO_Bind_Dispatcher_Guard::status (void)
 {
   return status_;
 }
diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp
index f064141a214..11a610a0959 100644
--- a/TAO/tao/Invocation.cpp
+++ b/TAO/tao/Invocation.cpp
@@ -57,33 +57,33 @@ enum
 
 // Setup Timeprobes
 ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Invocation_Timeprobe_Description,
-				  TAO_GIOP_INVOCATION_INVOKE_START);
+                                  TAO_GIOP_INVOCATION_INVOKE_START);
 
-#endif /* ACE_ENABLE_TIMEPROBES	*/
+#endif /* ACE_ENABLE_TIMEPROBES */
 
-// Normal invocations don't involve any	heap al; messages are
-// constructed into stack-based	buffers	and are	read into those
-// buffers too.	 Larger	buffers	are heap-allocated as needed.
+// Normal invocations don't involve any heap al; messages are
+// constructed into stack-based buffers and are read into those
+// buffers too.  Larger buffers are heap-allocated as needed.
 //
-// The constraint on request IDs is that no two	requests from the same
-// client with the same	ID are outstanding at the same time.  In
-// single threaded environments, this is met by	any number whatever.
-// When	multiple threads are used, we eliminate	the need for any
-// locked state	by using the thread ID as the request ID, since	any
-// given thread	has at most one	request	outstanding at a time.
+// The constraint on request IDs is that no two requests from the same
+// client with the same ID are outstanding at the same time.  In
+// single threaded environments, this is met by any number whatever.
+// When multiple threads are used, we eliminate the need for any
+// locked state by using the thread ID as the request ID, since any
+// given thread has at most one request outstanding at a time.
 //
 // NOTE: this means that if "deferred synchronous" calls get
-// supported, it's done	by creating a thread internally	to make	the
+// supported, it's done by creating a thread internally to make the
 // call.  That is less disruptive (and error prone) in general than
-// restructuring an ORB	core in	terms of asynchrony.
+// restructuring an ORB core in terms of asynchrony.
 // ****************************************************************
 
 TAO_GIOP_Invocation::TAO_GIOP_Invocation (void)
   : stub_ (0),
-    op_details_	(0,
-		 0,
-		 0),
-    out_stream_	(),
+    op_details_ (0,
+                 0,
+                 0),
+    out_stream_ (),
     orb_core_ (0),
     transport_ (0),
     endpoint_selector_ (0),
@@ -98,22 +98,22 @@ TAO_GIOP_Invocation::TAO_GIOP_Invocation (void)
 }
 
 TAO_GIOP_Invocation::TAO_GIOP_Invocation (TAO_Stub *stub,
-					  const	char *operation,
-					  CORBA::ULong opname_len,
-					  CORBA::Boolean argument_flag,
-					  TAO_ORB_Core *orb_core)
+                                          const char *operation,
+                                          CORBA::ULong opname_len,
+                                          CORBA::Boolean argument_flag,
+                                          TAO_ORB_Core *orb_core)
   : stub_ (stub),
-    op_details_	(operation,
-		 opname_len,
-		 argument_flag),
-    out_stream_	(this->buffer_,
-		 sizeof	this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */
-		 TAO_ENCAP_BYTE_ORDER,
-		 orb_core->output_cdr_buffer_allocator (),
-		 orb_core->output_cdr_dblock_allocator (),
-		 orb_core->orb_params ()->cdr_memcpy_tradeoff (),
-		 orb_core->to_iso8859 (),
-		 orb_core->to_unicode ()),
+    op_details_ (operation,
+                 opname_len,
+                 argument_flag),
+    out_stream_ (this->buffer_,
+                 sizeof this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */
+                 TAO_ENCAP_BYTE_ORDER,
+                 orb_core->output_cdr_buffer_allocator (),
+                 orb_core->output_cdr_dblock_allocator (),
+                 orb_core->orb_params ()->cdr_memcpy_tradeoff (),
+                 orb_core->to_iso8859 (),
+                 orb_core->to_unicode ()),
     orb_core_ (orb_core),
     transport_ (0),
     endpoint_selector_ (0),
@@ -131,66 +131,66 @@ TAO_GIOP_Invocation::~TAO_GIOP_Invocation (void)
 {
 }
 
-// The public API involves creating an invocation, starting it,	filling
+// The public API involves creating an invocation, starting it, filling
 // in request parameters, actually performing the invocation, getting
-// response parameters,	and then cleaning up.  Sometimes they must be
-// restarted (e.g. request forwarding).	 This is the start/restart entry.
+// response parameters, and then cleaning up.  Sometimes they must be
+// restarted (e.g. request forwarding).  This is the start/restart entry.
 
 void
 TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_FUNCTION_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER);
-  TAO_MINIMAL_TIMEPROBE	(TAO_GIOP_INVOCATION_START_ENTER);
+  TAO_MINIMAL_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER);
 
   // First try to bind to the appropriate address.  We do that here
-  // since we may get forwarded	to a different objref in the course of
-  // any given call, with new start () call each time.	It's not
+  // since we may get forwarded to a different objref in the course of
+  // any given call, with new start () call each time.  It's not
   // cached in the objref data since the connections change
-  // asynchronously from objref	invocations and	this simplifies
-  // connection	management.
-  // We	also need to bind *before* marshalling,	because	different
-  // Profiles have different ObjectKeys, thus a	change of Profile can
+  // asynchronously from objref invocations and this simplifies
+  // connection management.
+  // We also need to bind *before* marshalling, because different
+  // Profiles have different ObjectKeys, thus a change of Profile can
   // result in different alignment for the buffer.
   //
-  // THREADING NOTE: this connection is	reserved to this call.	Also,
-  // starting at this point in the call, new forwarding	information
+  // THREADING NOTE: this connection is reserved to this call.  Also,
+  // starting at this point in the call, new forwarding information
   // will not be used until/unless the call is reissued.  Correctness
-  // is	not affected, the call will just be forwarded later than it
-  // might be in a more	complex	implementation.
+  // is not affected, the call will just be forwarded later than it
+  // might be in a more complex implementation.
 
-  // @@	assert is evil,	it crashes the program,	changed	to an
+  // @@ assert is evil, it crashes the program, changed to an
   // exception (coryan)
   // assert (this->stub_ != 0);
 
   if (this->stub_ == 0)
     {
-      ACE_THROW	(CORBA::INTERNAL (
-		   CORBA_SystemException::_tao_minor_code (
-		     TAO_DEFAULT_MINOR_CODE,
-		     EINVAL),
-		CORBA::COMPLETED_NO));
+      ACE_THROW (CORBA::INTERNAL (
+                   CORBA_SystemException::_tao_minor_code (
+                     TAO_DEFAULT_MINOR_CODE,
+                     EINVAL),
+                CORBA::COMPLETED_NO));
     }
 
   // Get a pointer to the connector registry, which might be in
-  // thread-specific storage, depending	on the concurrency model.
+  // thread-specific storage, depending on the concurrency model.
   TAO_Connector_Registry *conn_reg =
-    this->orb_core_->connector_registry	();
+    this->orb_core_->connector_registry ();
 
   if (conn_reg == 0)
     {
-      ACE_THROW	(CORBA::INTERNAL (
-		   CORBA_SystemException::_tao_minor_code (
-		     TAO_DEFAULT_MINOR_CODE,
-		     EINVAL),
-		   CORBA::COMPLETED_NO));
+      ACE_THROW (CORBA::INTERNAL (
+                   CORBA_SystemException::_tao_minor_code (
+                     TAO_DEFAULT_MINOR_CODE,
+                     EINVAL),
+                   CORBA::COMPLETED_NO));
     }
 
-  // Initialize	endpoint selection strategy.
+  // Initialize endpoint selection strategy.
   if (!this->is_selector_initialized_)
     {
       this->orb_core_->endpoint_selector_factory ()->get_selector (this,
-								   ACE_TRY_ENV);
+                                                                   ACE_TRY_ENV);
       ACE_CHECK;
       this->is_selector_initialized_ = 1;
     }
@@ -199,40 +199,40 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
     {
       int has_timeout;
       this->orb_core_->call_timeout_hook (this->stub_,
-					  has_timeout,
-					  this->max_wait_time_value_);
+                                          has_timeout,
+                                          this->max_wait_time_value_);
       if (has_timeout)
-	{
-	  this->max_wait_time_ = &this->max_wait_time_value_;
-	}
+        {
+          this->max_wait_time_ = &this->max_wait_time_value_;
+        }
     }
 
   ACE_Countdown_Time countdown (this->max_wait_time_);
 
-  // Loop until	a connection is	established or there aren't any	more
+  // Loop until a connection is established or there aren't any more
   // profiles to try.
   for (;;)
     {
       // Allow loaded services to select the profile.
       if (this->stub_->service_profile_selection ())
-	{
-	  this->profile_ = this->stub_->profile_in_use ();
-	  this->endpoint_ = this->profile_->endpoint ();
-	}
+        {
+          this->profile_ = this->stub_->profile_in_use ();
+          this->endpoint_ = this->profile_->endpoint ();
+        }
       else
-	{
-	  // If	loaded services	have nothing to	say on
-	  // profile/endpoint selection, let the strategy do the work.
-	  this->endpoint_selector_->select_endpoint (this,
-						     ACE_TRY_ENV);
-	  ACE_CHECK;
-	}
+        {
+          // If loaded services have nothing to say on
+          // profile/endpoint selection, let the strategy do the work.
+          this->endpoint_selector_->select_endpoint (this,
+                                                     ACE_TRY_ENV);
+          ACE_CHECK;
+        }
 
       // Get the transport object.
       if (this->transport_ != 0)
-	{
-	  this->transport_->idle ();
-	}
+        {
+          this->transport_->idle ();
+        }
 
       // Create descriptor for the connection we need to find.
       TAO_Connection_Descriptor_Interface *desc;
@@ -242,49 +242,49 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
 #if (TAO_HAS_RT_CORBA == 1)
 
       // RTCORBA::PrivateConnectionPolicy processing.
-      TAO_Private_Connection_Descriptor 
+      TAO_Private_Connection_Descriptor
         private_desc (this->endpoint_,
                       ACE_reinterpret_cast (long, this->stub_));
       if (this->endpoint_selection_state_.private_connection_)
         desc = &private_desc;
 
-#endif /* TAO_HAS_RT_CORBA == 1	*/
+#endif /* TAO_HAS_RT_CORBA == 1 */
 
-      // Obtain	a connection.
+      // Obtain a connection.
       int result = conn_reg->connect (desc,
-				      this->transport_,
-				      this->max_wait_time_,
-				      ACE_TRY_ENV);
+                                      this->transport_,
+                                      this->max_wait_time_,
+                                      ACE_TRY_ENV);
       ACE_CHECK;
 
       if (result == 0)
-	{
-	  // Now that we have the client connection handler object we need to
-	  // set the right messaging protocol for in the client	side transport.
-	  const	TAO_GIOP_Version& version = this->profile_->version ();
-	  result = this->transport_->messaging_init (version.major,
-						     version.minor);
-	  if (result ==	-1)
-	    {
-	      if (TAO_debug_level > 0)
-		{
-		  ACE_DEBUG ((LM_DEBUG,
-			      ACE_TEXT ("(%N|%l|%p|%t) ")
-			      ACE_TEXT ("messaging_init() failed\n")));
-		}
-	    }
-	  else
-	    break;
-	}
-
-      if (errno	== ETIME)
-	{
-	  ACE_THROW (CORBA::TIMEOUT (
-	      CORBA_SystemException::_tao_minor_code (
-		  TAO_TIMEOUT_CONNECT_MINOR_CODE,
-		  errno),
-	      CORBA::COMPLETED_NO));
-	}
+        {
+          // Now that we have the client connection handler object we need to
+          // set the right messaging protocol for in the client side transport.
+          const TAO_GIOP_Version& version = this->profile_->version ();
+          result = this->transport_->messaging_init (version.major,
+                                                     version.minor);
+          if (result == -1)
+            {
+              if (TAO_debug_level > 0)
+                {
+                  ACE_DEBUG ((LM_DEBUG,
+                              ACE_TEXT ("(%N|%l|%p|%t) ")
+                              ACE_TEXT ("messaging_init() failed\n")));
+                }
+            }
+          else
+            break;
+        }
+
+      if (errno == ETIME)
+        {
+          ACE_THROW (CORBA::TIMEOUT (
+              CORBA_SystemException::_tao_minor_code (
+                  TAO_TIMEOUT_CONNECT_MINOR_CODE,
+                  errno),
+              CORBA::COMPLETED_NO));
+        }
 
       // Try another profile/endpoint.
       this->endpoint_selector_->next (this, ACE_TRY_ENV);
@@ -295,129 +295,129 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
 
   // Obtain unique request id from the RMS.
   this->op_details_.request_id (
-	this->transport_->tms ()->request_id ());
+        this->transport_->tms ()->request_id ());
 
-  // Make sure that you	have the right object key
+  // Make sure that you have the right object key
   this->target_spec_.target_specifier (this->profile_->object_key ());
 }
 
 void
 TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags,
-				     CORBA_Environment &ACE_TRY_ENV)
+                                     CORBA_Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   // Then fill in the rest of the RequestHeader
 
   // Fill up the service context lists
   // First lookup at the services to see whether they have anything to
-  // add to the	service	context	lists
-  this->orb_core_->service_context_list	(this->stub_,
-					 this->service_info (),
-					 this->restart_flag_,
-					 ACE_TRY_ENV);
+  // add to the service context lists
+  this->orb_core_->service_context_list (this->stub_,
+                                         this->service_info (),
+                                         this->restart_flag_,
+                                         ACE_TRY_ENV);
   ACE_CHECK;
 
   this->add_rt_service_context (ACE_TRY_ENV);
   ACE_CHECK;
 
-  // The target	specification mode
+  // The target specification mode
   if (this->stub_->addressing_mode () ==
       TAO_Target_Specification::Key_Addr)
     {
       this->target_spec_.target_specifier (
-	    this->profile_->object_key ());
+            this->profile_->object_key ());
     }
-  else if (this->stub_->addressing_mode	()
-	     ==	TAO_Target_Specification::Profile_Addr)
+  else if (this->stub_->addressing_mode ()
+             == TAO_Target_Specification::Profile_Addr)
     {
       this->target_spec_.target_specifier (
-		this->profile_->create_tagged_profile ()
-	      );
+                this->profile_->create_tagged_profile ()
+              );
     }
-  else if (this->stub_->addressing_mode	()
-	     ==	TAO_Target_Specification::Reference_Addr)
+  else if (this->stub_->addressing_mode ()
+             == TAO_Target_Specification::Reference_Addr)
     {
-      // We need to call the method seperately.	If there is no
-      // IOP::IOR info,	the call would create the info and return the
+      // We need to call the method seperately. If there is no
+      // IOP::IOR info, the call would create the info and return the
       // index that we need.
-      // @@Will	not work for RT	CORBA as the index we get would	be
+      // @@Will not work for RT CORBA as the index we get would be
       // wrong.
       CORBA::ULong index = this->create_ior_info ();
       this->target_spec_.target_specifier (this->ior_info_,
-					   index);
+                                           index);
     }
 
-  // Update the	response flags
+  // Update the response flags
   this->op_details_.response_flags (response_flags);
 
   // Send the request for the header
   if (this->transport_->send_request_header (this->op_details_,
-					     this->target_spec_,
-					     this->out_stream_)
-	== 0)
+                                             this->target_spec_,
+                                             this->out_stream_)
+        == 0)
     {
-      ACE_THROW	(CORBA::MARSHAL	());
+      ACE_THROW (CORBA::MARSHAL ());
     }
 }
 
 
-// Send	request.
+// Send request.
 int
 TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
-			     CORBA::Environment	&ACE_TRY_ENV)
+                             CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
   ACE_Countdown_Time countdown (this->max_wait_time_);
 
   if (this->transport_ == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL	(),
-			TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL (),
+                        TAO_INVOKE_EXCEPTION);
     }
 
-  // @@	Alex: the <is_roundtrip> flag will be tricky when we move to
-  //	AMI: now it is used both to indicate the the CORBA request in
-  //	a twoway and that the send_request() operation should block.
-  //	Even for oneways: with AMI it is possible to wait for a
-  //	response (empty) for oneways, just to make sure	that they
-  //	arrive,	there are policies to control that.
+  // @@ Alex: the <is_roundtrip> flag will be tricky when we move to
+  //    AMI: now it is used both to indicate the the CORBA request in
+  //    a twoway and that the send_request() operation should block.
+  //    Even for oneways: with AMI it is possible to wait for a
+  //    response (empty) for oneways, just to make sure that they
+  //    arrive, there are policies to control that.
 
   int result =
     this->transport_->send_request (this->stub_,
-				    this->orb_core_,
-				    this->out_stream_,
-				    is_roundtrip,
-				    this->max_wait_time_);
+                                    this->orb_core_,
+                                    this->out_stream_,
+                                    is_roundtrip,
+                                    this->max_wait_time_);
 
   //
-  // @@	highly desirable to know whether we wrote _any_	data; if
-  // we	wrote none, then there's no chance the call completed and
-  // applications don't	have to	deal with those	nasty
-  // indeterminate states where	they can't immediatly tell if
+  // @@ highly desirable to know whether we wrote _any_ data; if
+  // we wrote none, then there's no chance the call completed and
+  // applications don't have to deal with those nasty
+  // indeterminate states where they can't immediatly tell if
   // what's safe to do.
   //
-  // @@	also, there might have been a GIOP::CloseConnection
-  // message in	the input queue.  If so, this request should be
-  // treated as	a (full) "rebind" case.	 Can't do that from this
-  // point in the code however!	 Some minor restructuring needs	to
+  // @@ also, there might have been a GIOP::CloseConnection
+  // message in the input queue.  If so, this request should be
+  // treated as a (full) "rebind" case.  Can't do that from this
+  // point in the code however!  Some minor restructuring needs to
   // happen.
   //
 
-  if (result ==	-1)
+  if (result == -1)
     {
-      if (errno	== ETIME)
-	{
-	  ACE_THROW_RETURN (
-	      CORBA::TIMEOUT (
-		  CORBA_SystemException::_tao_minor_code (
-		      TAO_TIMEOUT_SEND_MINOR_CODE,
-		      errno
-		    ),
-		  CORBA::COMPLETED_NO
-		),
-	      TAO_INVOKE_EXCEPTION
-	    );
-	}
+      if (errno == ETIME)
+        {
+          ACE_THROW_RETURN (
+              CORBA::TIMEOUT (
+                  CORBA_SystemException::_tao_minor_code (
+                      TAO_TIMEOUT_SEND_MINOR_CODE,
+                      errno
+                    ),
+                  CORBA::COMPLETED_NO
+                ),
+              TAO_INVOKE_EXCEPTION
+            );
+        }
       this->transport_->close_connection ();
       this->transport_ = 0;
 
@@ -426,9 +426,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
       return TAO_INVOKE_RESTART;
     }
 
-  // Indicate that the endpoint/profile	was used successfully.
-  // @@	Maybe the right	place to do this is once the reply is
-  //	received? But what about oneways?
+  // Indicate that the endpoint/profile was used successfully.
+  // @@ Maybe the right place to do this is once the reply is
+  //    received? But what about oneways?
   this->endpoint_selector_->success (this);
 
   return TAO_INVOKE_OK;
@@ -437,9 +437,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip,
 int
 TAO_GIOP_Invocation::close_connection (void)
 {
-  // Special case of forwarding	-- server was closing the
-  // connection, which just indicates resource constraints, not	an
-  // error.  The client	is effectively "forwarded" to the same
+  // Special case of forwarding -- server was closing the
+  // connection, which just indicates resource constraints, not an
+  // error.  The client is effectively "forwarded" to the same
   // server!
   //
   // However, we must reinitialize the forwarding chain, since the
@@ -465,12 +465,12 @@ TAO_GIOP_Invocation::close_connection (void)
 
 int
 TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
-				       CORBA::Environment &ACE_TRY_ENV)
+                                       CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  // It	can be assumed that the	GIOP header and	the reply header
+  // It can be assumed that the GIOP header and the reply header
   // are already handled. Further it can be assumed that the
-  // reply body	contains an object reference to	the new	object.
+  // reply body contains an object reference to the new object.
   // This object pointer will be now extracted.
 
   CORBA::Object_var object = 0;
@@ -478,23 +478,23 @@ TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
   if ( (inp_stream >> object.inout ()) == 0)
     {
       ACE_THROW_RETURN (CORBA::MARSHAL (),
-			TAO_INVOKE_EXCEPTION);
+                        TAO_INVOKE_EXCEPTION);
     }
 
-  // The object	pointer	has to be changed to a TAO_Stub	pointer
-  // in	order to obtain	the profiles.
+  // The object pointer has to be changed to a TAO_Stub pointer
+  // in order to obtain the profiles.
   TAO_Stub *stubobj = object->_stubobj ();
 
   if (stubobj == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL	(),
-			TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL (),
+                        TAO_INVOKE_EXCEPTION);
     }
 
-  // Modify the	state as appropriate to	include	new forwarding profiles.
+  // Modify the state as appropriate to include new forwarding profiles.
   this->endpoint_selector_->forward (this,
-				     stubobj->base_profiles (),
-				     ACE_TRY_ENV);
+                                     stubobj->base_profiles (),
+                                     ACE_TRY_ENV);
   ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
 
   return TAO_INVOKE_RESTART;
@@ -505,34 +505,34 @@ CORBA::ULong
 TAO_GIOP_Invocation::create_ior_info (void)
 {
   // Get the list of profiles
-  const	TAO_MProfile &mprofile = this->stub_->base_profiles ();
+  const TAO_MProfile &mprofile = this->stub_->base_profiles ();
 
   if (this->ior_info_.profiles.length () == 0)
     {
-      // We are	making a copy, it is expensive.	We want	a copy of the
-      // profiles as we	dont want to modify the	profile	set held by
+      // We are making a copy, it is expensive. We want a copy of the
+      // profiles as we dont want to modify the profile set held by
       // the Stub classes. We may want to hold a lock for doing
-      // that. To avoid	unnecssary complications we make a copy	and
+      // that. To avoid unnecssary complications we make a copy and
       // get the info
 
       // @@ There should be a better way to do this - Bala
       TAO_MProfile *multi_prof =
-	this->stub_->make_profiles ();
+        this->stub_->make_profiles ();
 
-      // Get the number	of elements
+      // Get the number of elements
       CORBA::ULong count = multi_prof->profile_count ();
 
-      // Set the number	of elements in the sequence of tagged_profile
+      // Set the number of elements in the sequence of tagged_profile
       this->ior_info_.profiles.length (count);
 
-      // Call the create_tagged_profile	one every member of the
+      // Call the create_tagged_profile one every member of the
       // profile and make the sequence
-      for (CORBA::ULong	index =	0; index < count; ++index)
-	{
-	  TAO_Profile *prof = multi_prof->get_profile (index);
+      for (CORBA::ULong index = 0; index < count; ++index)
+        {
+          TAO_Profile *prof = multi_prof->get_profile (index);
 
-	  this->ior_info_.profiles[index] = prof->create_tagged_profile	();
-	}
+          this->ior_info_.profiles[index] = prof->create_tagged_profile ();
+        }
 
       delete multi_prof;
     }
@@ -544,8 +544,8 @@ void
 TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV)
 {
   // RTCORBA-specific processing.
-  // If	invocation target supports RTCORBA::CLIENT_PROPAGATED priority
-  // model, we must add	IOP::RTCorbaPriority service context to	the
+  // If invocation target supports RTCORBA::CLIENT_PROPAGATED priority
+  // model, we must add IOP::RTCorbaPriority service context to the
   // list.
 
 #if (TAO_HAS_RT_CORBA == 1)
@@ -560,58 +560,58 @@ TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV)
   if (this->endpoint_selection_state_.priority_model_policy_)
     {
       if (this->endpoint_selection_state_.priority_model_policy_->
-	  get_priority_model ()	== RTCORBA::CLIENT_PROPAGATED)
-	{
-	  // Encapsulate the priority of the current thread into
-	  // a service context.
-	  TAO_OutputCDR	cdr;
-	  if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
-	       == 0)
-	      || (cdr << this->endpoint_selection_state_.client_priority_)
-	      == 0)
-	    ACE_THROW (CORBA::MARSHAL ());
-
-	  IOP::ServiceContextList &context_list	= this->service_info ();
-
-	  CORBA::ULong l = context_list.length ();
-	  context_list.length (l + 1);
-	  context_list[l].context_id = IOP::RTCorbaPriority;
-
-	  // Make a *copy* of the CDR stream...
-	  CORBA::ULong length =	cdr.total_length ();
-	  context_list[l].context_data.length (length);
-	  CORBA::Octet *buf = context_list[l].context_data.get_buffer ();
-
-	  for (const ACE_Message_Block *i = cdr.begin ();
-	       i != 0;
-	       i = i->cont ())
-	    {
-	      ACE_OS::memcpy (buf,
-			      i->rd_ptr	(),
-			      i->length	());
-	      buf += i->length ();
-	    }
-	}
+          get_priority_model () == RTCORBA::CLIENT_PROPAGATED)
+        {
+          // Encapsulate the priority of the current thread into
+          // a service context.
+          TAO_OutputCDR cdr;
+          if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
+               == 0)
+              || (cdr << this->endpoint_selection_state_.client_priority_)
+              == 0)
+            ACE_THROW (CORBA::MARSHAL ());
+
+          IOP::ServiceContextList &context_list = this->service_info ();
+
+          CORBA::ULong l = context_list.length ();
+          context_list.length (l + 1);
+          context_list[l].context_id = IOP::RTCorbaPriority;
+
+          // Make a *copy* of the CDR stream...
+          CORBA::ULong length = cdr.total_length ();
+          context_list[l].context_data.length (length);
+          CORBA::Octet *buf = context_list[l].context_data.get_buffer ();
+
+          for (const ACE_Message_Block *i = cdr.begin ();
+               i != 0;
+               i = i->cont ())
+            {
+              ACE_OS::memcpy (buf,
+                              i->rd_ptr (),
+                              i->length ());
+              buf += i->length ();
+            }
+        }
     }
   else
     {
       // The Object does not contain PriorityModel policy in its IOR.
-      // We must be talking to a non-RT	ORB.  Do nothing.
+      // We must be talking to a non-RT ORB.  Do nothing.
     }
 
-  this->rt_context_initialized_	= 1;
+  this->rt_context_initialized_ = 1;
 
 #else
   ACE_UNUSED_ARG (ACE_TRY_ENV);
 
-#endif /* TAO_HAS_RT_CORBA == 1	*/
+#endif /* TAO_HAS_RT_CORBA == 1 */
 }
 
 // ****************************************************************
 
 TAO_GIOP_Synch_Invocation::TAO_GIOP_Synch_Invocation (void)
-  : rd_	(0,
-	 this->op_details_.service_info	())
+  : rd_ (0,
+         this->op_details_.service_info ())
 {
 }
 
@@ -625,88 +625,88 @@ TAO_GIOP_Synch_Invocation::~TAO_GIOP_Synch_Invocation (void)
 
 int
 TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
-				     CORBA::Environment	&ACE_TRY_ENV)
+                                     CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  // Register a	reply dispatcher for this invocation. Use the
-  // preallocated reply	dispatcher.
+  // Register a reply dispatcher for this invocation. Use the
+  // preallocated reply dispatcher.
 
   // Bind.
 
   TAO_Transport_Mux_Strategy *tms = this->transport_->tms ();
 
   TAO_Bind_Dispatcher_Guard dispatch_guard (this->op_details_.request_id(),
-					    &this->rd_,
-					    tms);
-  int retval = dispatch_guard.status ();
+                                            &this->rd_,
+                                            tms);
+  int &status = dispatch_guard.status ();
 
-  if (retval ==	-1)
+  if (status == -1)
     {
-      // @@ What is the	right way to handle this error?
+      // @@ What is the right way to handle this error?
       this->close_connection ();
 
-      ACE_THROW_RETURN (CORBA::INTERNAL	(TAO_DEFAULT_MINOR_CODE,
-					 CORBA::COMPLETED_NO),
-			TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE,
+                                         CORBA::COMPLETED_NO),
+                        TAO_INVOKE_EXCEPTION);
     }
 
   // Just send the request, without trying to wait for the reply.
-  retval = TAO_GIOP_Invocation::invoke (1,
-					ACE_TRY_ENV);
+  int retval = TAO_GIOP_Invocation::invoke (1,
+                                            ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  if (retval !=	TAO_INVOKE_OK)
+  if (retval != TAO_INVOKE_OK)
     {
       return retval;
     }
 
   // This blocks until the response is read.  In the current version,
   // there is only one client thread that ever uses this connection,
-  // so	most response messages are illegal.
+  // so most response messages are illegal.
   //
-  // @@	In all MT environments,	there's	a cancellation point lurking
-  // here; need	to investigate.	 Client	threads	would frequently be
+  // @@ In all MT environments, there's a cancellation point lurking
+  // here; need to investigate.  Client threads would frequently be
   // canceled sometime during recv_request ... the correct action to
-  // take on being canceled is to issue	a CancelRequest	message	to the
-  // server and	then imediately	let other client-side cancellation
+  // take on being canceled is to issue a CancelRequest message to the
+  // server and then imediately let other client-side cancellation
   // handlers do their jobs.
   //
-  // In	C++, that basically means to unwind the	stack using almost
-  // normal procedures:	all destructors	should fire, and some "catch"
+  // In C++, that basically means to unwind the stack using almost
+  // normal procedures: all destructors should fire, and some "catch"
   // blocks should probably be able to handle things like releasing
-  // pointers. (Without	unwinding the C++ stack, resources that	must
-  // be	freed by thread	cancellation won't be freed, and the process
-  // won't continue to function	correctly.)  The tricky	part is	that
+  // pointers. (Without unwinding the C++ stack, resources that must
+  // be freed by thread cancellation won't be freed, and the process
+  // won't continue to function correctly.)  The tricky part is that
   // according to POSIX, all C stack frames must also have their
-  // (explicitly coded)	handlers called.  We assume a POSIX.1c/C/C++
+  // (explicitly coded) handlers called.  We assume a POSIX.1c/C/C++
   // environment.
 
   // Get the reply status.
 
   // Wait for the reply.
 
-  if (TAO_debug_level >	0 && this->max_wait_time_ != 0)
+  if (TAO_debug_level > 0 && this->max_wait_time_ != 0)
     {
       CORBA::ULong msecs = this->max_wait_time_->msec ();
 
-      ACE_DEBUG	((LM_DEBUG,
-		  ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"),
-		  msecs));
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"),
+                  msecs));
     }
 
   int reply_error =
     this->transport_->wait_strategy ()->wait (this->max_wait_time_,
-					      this->rd_.reply_received ());
+                                              this->rd_.reply_received ());
 
 
-  if (TAO_debug_level >	0 && this->max_wait_time_ != 0)
+  if (TAO_debug_level > 0 && this->max_wait_time_ != 0)
     {
       CORBA::ULong msecs = this->max_wait_time_->msec ();
 
-      ACE_DEBUG	((LM_DEBUG,
-		  ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"),
-		  msecs,
-		  reply_error));
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"),
+                  msecs,
+                  reply_error));
     }
 
   // Check the reply error.
@@ -714,41 +714,49 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
   if (reply_error == -1)
     {
       // The guard automatically unbinds the dispatcher.
-      if (errno	== ETIME)
-	{
-	  // Just a timeout, don't close the connection	or
-	  // anything...
-	  ACE_THROW_RETURN (CORBA::TIMEOUT (
-	      CORBA_SystemException::_tao_minor_code (
-		  TAO_TIMEOUT_SEND_MINOR_CODE,
-		  errno),
-	      CORBA::COMPLETED_NO),
-	    TAO_INVOKE_EXCEPTION);
-	}
-
-      // Call the ORB Core which would check whether we	need to	really
-      // raise an exception or are we going to base our	decision on the
-      // loaded	services.
+      if (errno == ETIME)
+        {
+          // Just a timeout, don't close the connection or
+          // anything...
+          ACE_THROW_RETURN (CORBA::TIMEOUT (
+              CORBA_SystemException::_tao_minor_code (
+                  TAO_TIMEOUT_SEND_MINOR_CODE,
+                  errno),
+              CORBA::COMPLETED_NO),
+            TAO_INVOKE_EXCEPTION);
+        }
+
+      // As there is an error set the status flag to -1
+      // @@ This is a hack. The problem is -- when an error occurs we
+      // @@ try to close the connection. This just goes and destroys
+      // @@ the transport object and so the TMS. When the Bind
+      // @@ Dispatcher Guard goes out of scope the destructor is
+      // @@ called and it uses the TMS, which is "bad". Let us have
+      // @@ this for the time being -- Bala
+      status = -1;
+      // Call the ORB Core which would check whether we need to really
+      // raise an exception or are we going to base our decision on the
+      // loaded services.
       return this->orb_core_->service_raise_comm_failure (this,
-							  this->profile_,
-							  ACE_TRY_ENV);
+                                                          this->profile_,
+                                                          ACE_TRY_ENV);
     }
 
-  // @@	Alex: the old version of this had some error handling code,
-  //	like:  this->profile_->reset_hint ()
-  //	Can you	make sure we don't forget to do	that on	exceptions
-  //	and/or errors.
-  //	BTW, think about native	exceptions where if the	exception is
-  //	raised in the wait() method you	won't get a chance
-  //	to do that kind	of error handling.  Do you really need
-  //	exceptions in the transport objects?
+  // @@ Alex: the old version of this had some error handling code,
+  //    like:  this->profile_->reset_hint ()
+  //    Can you make sure we don't forget to do that on exceptions
+  //    and/or errors.
+  //    BTW, think about native exceptions where if the exception is
+  //    raised in the wait() method you won't get a chance
+  //    to do that kind of error handling.  Do you really need
+  //    exceptions in the transport objects?
 
   CORBA::ULong reply_status = this->rd_.reply_status ();
 
   if (is_locate_request)
     {
-      // A locate request checks a different set of enum return	values,
-      // so we return to the TAO_GIOP_Locate_Request_Invocation	caller
+      // A locate request checks a different set of enum return values,
+      // so we return to the TAO_GIOP_Locate_Request_Invocation caller
       // to do that.
       return reply_status;
     }
@@ -756,92 +764,92 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request,
   switch (reply_status)
     {
     case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION:
-      // Return	so that	the STUB can demarshal the reply.
+      // Return so that the STUB can demarshal the reply.
       return TAO_INVOKE_OK;
 
     case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION:
-	// Return so the exception can be handled.
-	return TAO_INVOKE_EXCEPTION;
+        // Return so the exception can be handled.
+        return TAO_INVOKE_EXCEPTION;
 
     case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION:
       {
-	// @@ Add the location macros for this exceptions...
-
-	CORBA::String_var type_id;
-
-	if ((this->inp_stream () >> type_id.inout ()) == 0)
-	  {
-	    // Could not demarshal the exception id, raise an local
-	    // CORBA::MARSHAL
-	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					      CORBA::COMPLETED_MAYBE),
-			      TAO_INVOKE_OK);
-	  }
-
-	CORBA::ULong minor = 0;
-	CORBA::ULong completion	= 0;
-
-	if ((this->inp_stream () >> minor) == 0
-	    || (this->inp_stream () >> completion) == 0)
-	  {
-	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					      CORBA::COMPLETED_MAYBE),
-			      TAO_INVOKE_OK);
-	  }
-
-	CORBA::SystemException*	ex =
-	  TAO_Exceptions::create_system_exception (type_id.in (),
-						   ACE_TRY_ENV);
-	ACE_CHECK_RETURN (TAO_INVOKE_OK);
-
-	if (ex == 0)
-	  {
-	    // @@ We should raise a CORBA::NO_MEMORY, but we ran out
-	    //	  of memory already. We	need a pre-allocated, TSS,
-	    //	  CORBA::NO_MEMORY instance
-	    ACE_NEW_RETURN (ex,
-			    CORBA::UNKNOWN,
-			    TAO_INVOKE_EXCEPTION);
-	  }
-
-	ex->minor (minor);
-	ex->completed (CORBA::CompletionStatus (completion));
-
-
-	// @@ There should be a	better way to raise this exception!
-	//    This code	works for both native and emulated exceptions,
-	//    but it is	ugly.
-	ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW	here.
-	return TAO_INVOKE_OK;
+        // @@ Add the location macros for this exceptions...
+
+        CORBA::String_var type_id;
+
+        if ((this->inp_stream () >> type_id.inout ()) == 0)
+          {
+            // Could not demarshal the exception id, raise an local
+            // CORBA::MARSHAL
+            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                              CORBA::COMPLETED_MAYBE),
+                              TAO_INVOKE_OK);
+          }
+
+        CORBA::ULong minor = 0;
+        CORBA::ULong completion = 0;
+
+        if ((this->inp_stream () >> minor) == 0
+            || (this->inp_stream () >> completion) == 0)
+          {
+            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                              CORBA::COMPLETED_MAYBE),
+                              TAO_INVOKE_OK);
+          }
+
+        CORBA::SystemException* ex =
+          TAO_Exceptions::create_system_exception (type_id.in (),
+                                                   ACE_TRY_ENV);
+        ACE_CHECK_RETURN (TAO_INVOKE_OK);
+
+        if (ex == 0)
+          {
+            // @@ We should raise a CORBA::NO_MEMORY, but we ran out
+            //    of memory already. We need a pre-allocated, TSS,
+            //    CORBA::NO_MEMORY instance
+            ACE_NEW_RETURN (ex,
+                            CORBA::UNKNOWN,
+                            TAO_INVOKE_EXCEPTION);
+          }
+
+        ex->minor (minor);
+        ex->completed (CORBA::CompletionStatus (completion));
+
+
+        // @@ There should be a better way to raise this exception!
+        //    This code works for both native and emulated exceptions,
+        //    but it is ugly.
+        ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW here.
+        return TAO_INVOKE_OK;
       }
       // NOTREACHED.
 
     case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD:
-      // Handle	the forwarding and return so the stub restarts the
+      // Handle the forwarding and return so the stub restarts the
       // request!
       return this->location_forward (this->inp_stream (),
-				     ACE_TRY_ENV);
+                                     ACE_TRY_ENV);
     case TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE:
       {
-	// We have received an exception with a	request	to change the
-	// addressing mode. First let us read the mode that the
-	// server/agent	asks for.
-	CORBA::Short addr_mode = 0;
-	if (this->inp_stream ().read_short (addr_mode) == 0)
-	  {
-	    // Could not demarshal the addressing disposition, raise an	local
-	    // CORBA::MARSHAL
-	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					      CORBA::COMPLETED_MAYBE),
-			      TAO_INVOKE_OK);
-	  }
-
-	// Now set this	addressing mode	in the stub object, so that
-	// the next invocation need not	go through this.
-	this->stub_->addressing_mode (addr_mode);
-
-	// Now restart the invocation
-	return TAO_INVOKE_RESTART;
+        // We have received an exception with a request to change the
+        // addressing mode. First let us read the mode that the
+        // server/agent asks for.
+        CORBA::Short addr_mode = 0;
+        if (this->inp_stream ().read_short (addr_mode) == 0)
+          {
+            // Could not demarshal the addressing disposition, raise an local
+            // CORBA::MARSHAL
+            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                              CORBA::COMPLETED_MAYBE),
+                              TAO_INVOKE_OK);
+          }
+
+        // Now set this addressing mode in the stub object, so that
+        // the next invocation need not go through this.
+        this->stub_->addressing_mode (addr_mode);
+
+        // Now restart the invocation
+        return TAO_INVOKE_RESTART;
       }
 
     }
@@ -859,91 +867,91 @@ TAO_GIOP_Twoway_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_request (this->orb_core_,
-				   this->target_spec_,
-				   this->out_stream_,
-				   ACE_TRY_ENV);
+                                   this->target_spec_,
+                                   this->out_stream_,
+                                   ACE_TRY_ENV);
 }
 
-// Send	request, block until any reply comes back, and unmarshal reply
+// Send request, block until any reply comes back, and unmarshal reply
 // parameters as appropriate.
 
 int
 TAO_GIOP_Twoway_Invocation::invoke (TAO_Exception_Data *excepts,
-				    CORBA::ULong except_count,
-				    CORBA::Environment &ACE_TRY_ENV)
+                                    CORBA::ULong except_count,
+                                    CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::Exception))
 {
   TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_INVOCATION_INVOKE_START);
 
   int retval = this->invoke_i (0,
-			       ACE_TRY_ENV);
+                               ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  // A TAO_INVOKE_EXCEPTION status, but	no exception raised means that
-  // we	have a user exception.
-  // @@	This is	a bit brittle, think about a better implementation.
-  if (retval ==	TAO_INVOKE_EXCEPTION)
+  // A TAO_INVOKE_EXCEPTION status, but no exception raised means that
+  // we have a user exception.
+  // @@ This is a bit brittle, think about a better implementation.
+  if (retval == TAO_INVOKE_EXCEPTION)
     {
       // Pull the exception from the stream.
-      CORBA::String_var	buf;
+      CORBA::String_var buf;
 
-      if ((this->inp_stream () >> buf.inout ())	== 0)
-	{
-	  // Could not demarshal the exception id, raise an local
-	  // CORBA::MARSHAL
-	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					    CORBA::COMPLETED_MAYBE),
-			    TAO_INVOKE_EXCEPTION);
-	}
+      if ((this->inp_stream () >> buf.inout ()) == 0)
+        {
+          // Could not demarshal the exception id, raise an local
+          // CORBA::MARSHAL
+          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                            CORBA::COMPLETED_MAYBE),
+                            TAO_INVOKE_EXCEPTION);
+        }
 
       // Match the exception interface repository id with the
       // exception in the exception list.
       // This is important to decode the exception.
 
-      for (CORBA::ULong	i = 0; i < except_count; ++i)
-	{
-	  CORBA::TypeCode_ptr tcp = excepts[i].tc;
-	  const	char *xid = tcp->id (ACE_TRY_ENV);
-	  ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
-
-	  if (ACE_OS::strcmp (buf.in (), xid) != 0)
-	    {
-	      continue;
-	    }
-
-	  // match
-	  CORBA::Exception *exception =	excepts[i].alloc ();
-
-	  if (exception	== 0)
-	    {
-	      ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE,
-						  CORBA::COMPLETED_YES),
-				TAO_INVOKE_EXCEPTION);
-	    }
-
-	  exception->_tao_decode (this->inp_stream (),
-				  ACE_TRY_ENV);
-	  ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
-
-	  if (TAO_debug_level >	5)
-	    {
-	      ACE_DEBUG	((LM_DEBUG,
-			  ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"),
-			  buf.in ()));
-	    }
-
-	  // @@	Think about a better way to raise the exception	here,
-	  //	maybe we need some more	macros?
-	  ACE_TRY_ENV.exception	(exception); //	We can not use ACE_THROW here.
-	  return TAO_INVOKE_EXCEPTION;
-	}
-
-      // If we couldn't	find the right exception, report it as
+      for (CORBA::ULong i = 0; i < except_count; ++i)
+        {
+          CORBA::TypeCode_ptr tcp = excepts[i].tc;
+          const char *xid = tcp->id (ACE_TRY_ENV);
+          ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
+
+          if (ACE_OS::strcmp (buf.in (), xid) != 0)
+            {
+              continue;
+            }
+
+          // match
+          CORBA::Exception *exception = excepts[i].alloc ();
+
+          if (exception == 0)
+            {
+              ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE,
+                                                  CORBA::COMPLETED_YES),
+                                TAO_INVOKE_EXCEPTION);
+            }
+
+          exception->_tao_decode (this->inp_stream (),
+                                  ACE_TRY_ENV);
+          ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
+
+          if (TAO_debug_level > 5)
+            {
+              ACE_DEBUG ((LM_DEBUG,
+                          ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"),
+                          buf.in ()));
+            }
+
+          // @@ Think about a better way to raise the exception here,
+          //    maybe we need some more macros?
+          ACE_TRY_ENV.exception (exception); // We can not use ACE_THROW here.
+          return TAO_INVOKE_EXCEPTION;
+        }
+
+      // If we couldn't find the right exception, report it as
       // CORBA::UNKNOWN.
 
       ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-					CORBA::COMPLETED_YES),
-			TAO_INVOKE_EXCEPTION);
+                                        CORBA::COMPLETED_YES),
+                        TAO_INVOKE_EXCEPTION);
     }
 
   return retval;
@@ -959,17 +967,17 @@ TAO_GIOP_Oneway_Invocation::TAO_GIOP_Oneway_Invocation (
     TAO_ORB_Core *orb_core
   )
   : TAO_GIOP_Synch_Invocation (stub,
-			       operation,
-			       opname_len,
-			       argument_flag,
-			       orb_core),
-    sync_scope_	(TAO::SYNC_WITH_TRANSPORT)
+                               operation,
+                               opname_len,
+                               argument_flag,
+                               orb_core),
+    sync_scope_ (TAO::SYNC_WITH_TRANSPORT)
 {
   int has_synchronization = 0;
   int scope = 0;
-  this->orb_core_->call_sync_scope_hook	(this->stub_,
-					 has_synchronization,
-					 scope);
+  this->orb_core_->call_sync_scope_hook (this->stub_,
+                                         has_synchronization,
+                                         scope);
 
   this->sync_scope_ = scope;
 }
@@ -982,50 +990,50 @@ TAO_GIOP_Oneway_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_request (this->orb_core_,
-				   this->target_spec_,
-				   this->out_stream_,
-				   ACE_TRY_ENV);
+                                   this->target_spec_,
+                                   this->out_stream_,
+                                   ACE_TRY_ENV);
 }
 
 int
 TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  if (this->sync_scope_	== TAO::SYNC_WITH_TRANSPORT
+  if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT
       || this->sync_scope_ == TAO::SYNC_NONE
       || this->sync_scope_ == TAO::SYNC_EAGER_BUFFERING
       || this->sync_scope_ == TAO::SYNC_DELAYED_BUFFERING)
     {
       return TAO_GIOP_Invocation::invoke (0,
-					  ACE_TRY_ENV);
+                                          ACE_TRY_ENV);
     }
 
   int retval = this->invoke_i (0,
-			       ACE_TRY_ENV);
+                               ACE_TRY_ENV);
   ACE_CHECK_RETURN (retval);
 
-  // A TAO_INVOKE_EXCEPTION status, but	no exception raised means that
-  // we	have a user exception.
-  // @@	This is	a bit brittle, think about a better implementation.
-  if (retval ==	TAO_INVOKE_EXCEPTION)
+  // A TAO_INVOKE_EXCEPTION status, but no exception raised means that
+  // we have a user exception.
+  // @@ This is a bit brittle, think about a better implementation.
+  if (retval == TAO_INVOKE_EXCEPTION)
     {
       // Pull the exception from the stream.
-      CORBA::String_var	buf;
-
-      if ((this->inp_stream () >> buf.inout ())	== 0)
-	{
-	  // Could not demarshal the exception id, raise an local
-	  // CORBA::MARSHAL
-	  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					    CORBA::COMPLETED_MAYBE),
-			    TAO_INVOKE_EXCEPTION);
-	}
-
-      // This kind of exception	shouldn't happen with oneways,
-      // but if	it does, we turn it into a CORBA::UNKNOWN exception.
+      CORBA::String_var buf;
+
+      if ((this->inp_stream () >> buf.inout ()) == 0)
+        {
+          // Could not demarshal the exception id, raise an local
+          // CORBA::MARSHAL
+          ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                            CORBA::COMPLETED_MAYBE),
+                            TAO_INVOKE_EXCEPTION);
+        }
+
+      // This kind of exception shouldn't happen with oneways,
+      // but if it does, we turn it into a CORBA::UNKNOWN exception.
       ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-					CORBA::COMPLETED_YES),
-			TAO_INVOKE_EXCEPTION);
+                                        CORBA::COMPLETED_YES),
+                        TAO_INVOKE_EXCEPTION);
     }
 
   return retval;
@@ -1041,25 +1049,25 @@ TAO_GIOP_Locate_Request_Invocation::start (CORBA_Environment &ACE_TRY_ENV)
   ACE_CHECK;
 
   this->transport_->start_locate (this->orb_core_,
-				  this->target_spec_,
-				  this->op_details_,
-				  this->out_stream_,
-				  ACE_TRY_ENV);
+                                  this->target_spec_,
+                                  this->op_details_,
+                                  this->out_stream_,
+                                  ACE_TRY_ENV);
 }
 
-// Send	request, block until any reply comes back.
+// Send request, block until any reply comes back.
 int
 TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
   ACE_THROW_SPEC ((CORBA::SystemException))
 {
   if (this->transport_ == 0)
     {
-      ACE_THROW_RETURN (CORBA::INTERNAL	(),
-			TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::INTERNAL (),
+                        TAO_INVOKE_EXCEPTION);
     }
 
   CORBA::ULong locate_status = this->invoke_i (1,
-					       ACE_TRY_ENV);
+                                               ACE_TRY_ENV);
   ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION);
 
   switch (locate_status)
@@ -1067,55 +1075,55 @@ TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
     case TAO_GIOP_OBJECT_HERE:
       break;
     case TAO_GIOP_UNKNOWN_OBJECT:
-      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST	(TAO_DEFAULT_MINOR_CODE,
-						 CORBA::COMPLETED_YES),
-			TAO_INVOKE_EXCEPTION);
+      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (TAO_DEFAULT_MINOR_CODE,
+                                                 CORBA::COMPLETED_YES),
+                        TAO_INVOKE_EXCEPTION);
       // NOTREACHED.
     case TAO_GIOP_OBJECT_FORWARD:
       return this->location_forward (this->inp_stream (),
-				     ACE_TRY_ENV);
+                                     ACE_TRY_ENV);
     case TAO_GIOP_LOC_SYSTEM_EXCEPTION:
       {
-	// Pull	the exception from the stream.
-	CORBA::String_var buf;
-
-	if ((this->inp_stream () >> buf.inout ()) == 0)
-	  {
-	    // Could not demarshal the exception id, raise a local
-	    // CORBA::MARSHAL exception.
-	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					      CORBA::COMPLETED_MAYBE),
-			      TAO_INVOKE_EXCEPTION);
-	  }
-
-	// This	kind of	exception shouldn't happen with	oneways,
-	// but if it does, we turn it into a CORBA::UNKNOWN exception.
-	ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
-					  CORBA::COMPLETED_YES),
-			  TAO_INVOKE_EXCEPTION);
+        // Pull the exception from the stream.
+        CORBA::String_var buf;
+
+        if ((this->inp_stream () >> buf.inout ()) == 0)
+          {
+            // Could not demarshal the exception id, raise a local
+            // CORBA::MARSHAL exception.
+            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                              CORBA::COMPLETED_MAYBE),
+                              TAO_INVOKE_EXCEPTION);
+          }
+
+        // This kind of exception shouldn't happen with oneways,
+        // but if it does, we turn it into a CORBA::UNKNOWN exception.
+        ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE,
+                                          CORBA::COMPLETED_YES),
+                          TAO_INVOKE_EXCEPTION);
       }
     case TAO_GIOP_LOC_NEEDS_ADDRESSING_MODE:
       {
-	// We have received an exception with a	request	to change the
-	// addressing mode. First let us read the mode that the
-	// server/agent	asks for.
-	CORBA::Short addr_mode = 0;
-
-	if (this->inp_stream ().read_short (addr_mode) == 0)
-	  {
-	    // Could not demarshal the addressing disposition, raise a local
-	    // CORBA::MARSHAL exception.
-	    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
-					      CORBA::COMPLETED_MAYBE),
-			      TAO_INVOKE_OK);
-	  }
-
-	// Now set this	addressing mode	in the stub object, so that
-	// the next invocation need not	go through this.
-	this->stub_->addressing_mode (addr_mode);
-
-	// Restart the invocation.
-	return TAO_INVOKE_RESTART;
+        // We have received an exception with a request to change the
+        // addressing mode. First let us read the mode that the
+        // server/agent asks for.
+        CORBA::Short addr_mode = 0;
+
+        if (this->inp_stream ().read_short (addr_mode) == 0)
+          {
+            // Could not demarshal the addressing disposition, raise a local
+            // CORBA::MARSHAL exception.
+            ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
+                                              CORBA::COMPLETED_MAYBE),
+                              TAO_INVOKE_OK);
+          }
+
+        // Now set this addressing mode in the stub object, so that
+        // the next invocation need not go through this.
+        this->stub_->addressing_mode (addr_mode);
+
+        // Restart the invocation.
+        return TAO_INVOKE_RESTART;
       }
     }