ChangeLogTag:

10 files changed, 626 insertions, 2 deletions

diff --git a/TAO/ChangeLog_ref b/TAO/ChangeLog_ref
index 0f64cb73496..9863ada21ae 100644
--- a/TAO/ChangeLog_ref
+++ b/TAO/ChangeLog_ref
@@ -1,3 +1,19 @@
+Tue Aug 26 17:44:56 2003  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
+
+	* tao/Strategies/DIOP_Connector.cpp:
+	* tao/Strategies/DIOP_Connector.h
+	* tao/Strategies/SCIOP_Connector.cpp
+	* tao/Strategies/SCIOP_Connector.h:
+	* tao/Strategies/SHMIOP_Connector.cpp:
+	* tao/Strategies/SHMIOP_Connector.h:
+	* tao/Strategies/UIOP_Connector.cpp:
+	* tao/Strategies/UIOP_Connector.h (make_connection): Implemented
+	  the new virtual function in all the protocols. This should get
+	  the strategies library building cleanly now.
+	
+	* tao/Strategies/advanced_resource.cpp: Added a couple of new
+	  #includes 
+
 Tue Aug 26 16:33:07 2003  Balachandran Natarajan  <bala@dre.vanderbilt.edu>
 
 	* tao/Transport.h:
diff --git a/TAO/tao/Strategies/DIOP_Connector.cpp b/TAO/tao/Strategies/DIOP_Connector.cpp
index 6eebb705664..b57a575a0a2 100644
--- a/TAO/tao/Strategies/DIOP_Connector.cpp
+++ b/TAO/tao/Strategies/DIOP_Connector.cpp
@@ -162,6 +162,55 @@ TAO_DIOP_Connector::make_connection (TAO_GIOP_Invocation *invocation,
   return 0;
 }
 
+TAO_Transport *
+TAO_DIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
+                                     TAO_Transport_Descriptor_Interface &desc,
+                                     ACE_Time_Value * /*max_wait_time*/)
+{
+  TAO_DIOP_Endpoint *diop_endpoint =
+    this->remote_endpoint (desc.endpoint ());
+
+  if (diop_endpoint == 0)
+    return 0;
+
+  const ACE_INET_Addr &remote_address =
+    diop_endpoint->object_addr ();
+
+  TAO_DIOP_Connection_Handler *svc_handler = 0;
+
+  if (svc_handler_table_.find (remote_address, svc_handler) == -1)
+    {
+      TAO_DIOP_Connection_Handler *svc_handler_i = 0;
+      ACE_NEW_RETURN (svc_handler_i,
+                      TAO_DIOP_Connection_Handler (this->orb_core (),
+                                                   this->lite_flag_,
+                                                   0 /* TAO_DIOP_Properties */),
+                      0);
+
+      svc_handler_i->local_addr (ACE_sap_any_cast (ACE_INET_Addr &));
+      svc_handler_i->addr (remote_address);
+
+      svc_handler_i->open (0);
+
+      svc_handler_table_.bind (remote_address,
+                               svc_handler_i);
+      svc_handler = svc_handler_i;
+
+      if (TAO_debug_level > 2)
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_TEXT ("(%P|%t) DIOP_Connector::connect - ")
+                    ACE_TEXT ("new connection on HANDLE %d\n"),
+                    svc_handler->get_handle ()));
+   }
+
+  // @@ Michael: We do not use regular connection management.
+  svc_handler->add_reference ();
+  TAO_Transport *transport =
+    svc_handler->transport ();
+
+  return transport;
+}
+
 TAO_Profile *
 TAO_DIOP_Connector::create_profile (TAO_InputCDR& cdr)
 {
diff --git a/TAO/tao/Strategies/DIOP_Connector.h b/TAO/tao/Strategies/DIOP_Connector.h
index 6fec62489ea..92b6696982f 100644
--- a/TAO/tao/Strategies/DIOP_Connector.h
+++ b/TAO/tao/Strategies/DIOP_Connector.h
@@ -81,6 +81,10 @@ protected:
                        TAO_Transport_Descriptor_Interface *desc,
                        ACE_Time_Value *timeout = 0);
 
+  TAO_Transport *make_connection (TAO::Profile_Transport_Resolver *r,
+                                  TAO_Transport_Descriptor_Interface &desc,
+                                  ACE_Time_Value *timeout = 0);
+
   virtual TAO_Profile * make_profile (ACE_ENV_SINGLE_ARG_DECL);
   //@}
 
diff --git a/TAO/tao/Strategies/SCIOP_Connector.cpp b/TAO/tao/Strategies/SCIOP_Connector.cpp
index a1cc0c7f60f..63b74255c00 100644
--- a/TAO/tao/Strategies/SCIOP_Connector.cpp
+++ b/TAO/tao/Strategies/SCIOP_Connector.cpp
@@ -153,8 +153,8 @@ TAO_SCIOP_Connector::set_validate_endpoint (TAO_Endpoint *endpoint)
 
 int
 TAO_SCIOP_Connector::make_connection (TAO_GIOP_Invocation *invocation,
-                                     TAO_Transport_Descriptor_Interface *desc,
-                                     ACE_Time_Value *max_wait_time)
+                                      TAO_Transport_Descriptor_Interface *desc,
+                                      ACE_Time_Value *max_wait_time)
 {
   TAO_SCIOP_Endpoint *sciop_endpoint =
     this->remote_endpoint (desc->endpoint ());
@@ -361,6 +361,209 @@ TAO_SCIOP_Connector::make_connection (TAO_GIOP_Invocation *invocation,
 }
 
 
+TAO_Transport *
+TAO_SCIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
+                                      TAO_Transport_Descriptor_Interface &desc,
+                                      ACE_Time_Value *max_wait_time)
+{
+  TAO_SCIOP_Endpoint *sciop_endpoint =
+    this->remote_endpoint (desc.endpoint ());
+
+  if (sciop_endpoint == 0)
+    return 0;
+
+  const ACE_INET_Addr &remote_address =
+    sciop_endpoint->object_addr ();
+
+  if (TAO_debug_level > 2)
+    ACE_DEBUG ((LM_DEBUG,
+                "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                "to <%s:%d>\n",
+                sciop_endpoint->host(), sciop_endpoint->port()));
+
+  // Get the right synch options
+  ACE_Synch_Options synch_options;
+
+  this->active_connect_strategy_->synch_options (max_wait_time,
+                                                 synch_options);
+
+  TAO_SCIOP_Connection_Handler *svc_handler = 0;
+
+  // Connect.
+  int result = this->base_connector_.connect (svc_handler,
+                                              remote_address,
+                                              synch_options);
+
+  // This call creates the service handler and bumps the #REFCOUNT# up
+  // one extra.  There are three possibilities: (a) connection
+  // succeeds immediately - in this case, the #REFCOUNT# on the
+  // handler is two; (b) connection completion is pending - in this
+  // case, the #REFCOUNT# on the handler is also two; (c) connection
+  // fails immediately - in this case, the #REFCOUNT# on the handler
+  // is one since close() gets called on the handler.
+  //
+  // The extra reference count in
+  // TAO_Connect_Creation_Strategy::make_svc_handler() is needed in
+  // the case when connection completion is pending and we are going
+  // to wait on a variable in the handler to changes, signifying
+  // success or failure.  Note, that this increment cannot be done
+  // once the connect() returns since this might be too late if
+  // another thread pick up the completion and potentially deletes the
+  // handler before we get a chance to increment the reference count.
+
+  // No immediate result.  Wait for completion.
+  if (result == -1 && errno == EWOULDBLOCK)
+    {
+      if (TAO_debug_level > 2)
+        ACE_DEBUG ((LM_DEBUG,
+                    "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                    "going to wait for connection completion on local"
+                    "handle [%d]\n",
+                    svc_handler->get_handle ()));
+
+      // Wait for connection completion.  No need to specify timeout
+      // to wait() since the correct timeout was passed to the
+      // Connector. The Connector will close the handler in the case
+      // of timeouts, so the event will complete (either success or
+      // failure) within timeout.
+      result =
+        this->active_connect_strategy_->wait (svc_handler,
+                                              0);
+
+      if (TAO_debug_level > 2)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "TAO (%P|%t) - SCIOP_Connector::make_connection"
+                      "wait done for handle[%d], result = %d\n",
+                      svc_handler->get_handle (), result));
+        }
+
+      // There are three possibilities when wait() returns: (a)
+      // connection succeeded; (b) connection failed; (c) wait()
+      // failed because of some other error.  It is easy to deal with
+      // (a) and (b).  (c) is tricky since the connection is still
+      // pending and may get completed by some other thread.  The
+      // following code deals with (c).
+
+      // Check if the handler has been closed.
+      int closed =
+        svc_handler->is_closed ();
+
+      // In case of failures and close() has not be called.
+      if (result == -1 &&
+          !closed)
+        {
+          // First, cancel from connector.
+          this->base_connector_.cancel (svc_handler);
+
+          // Double check to make sure the handler has not been closed
+          // yet.  This double check is required to ensure that the
+          // connection handler was not closed yet by some other
+          // thread since it was still registered with the connector.
+          // Once connector.cancel() has been processed, we are
+          // assured that the connector will no longer open/close this
+          // handler.
+          closed =
+            svc_handler->is_closed ();
+
+          // If closed, there is nothing to do here.  If not closed,
+          // it was either opened or is still pending.
+          if (!closed)
+            {
+              // Check if the handler has been opened.
+              int open =
+                svc_handler->is_open ();
+
+              // Some other thread was able to open the handler even
+              // though wait failed for this thread.
+              if (open)
+                // Overwrite <result>.
+                result = 0;
+              else
+                {
+                  // Assert that it is still connecting.
+                  ACE_ASSERT (svc_handler->is_connecting ());
+
+                  // Force close the handler now.
+                  svc_handler->close ();
+                }
+            }
+        }
+    }
+
+  // Irrespective of success or failure, remove the extra #REFCOUNT#.
+  svc_handler->remove_reference ();
+
+  // In case of errors.
+  if (result == -1)
+    {
+      // Give users a clue to the problem.
+      if (TAO_debug_level)
+        {
+          ACE_DEBUG ((LM_ERROR,
+                      "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                      "connection to <%s:%d> failed (%p)\n",
+                      sciop_endpoint->host (), sciop_endpoint->port (),
+                      "errno"));
+        }
+
+      return 0;
+    }
+
+  // At this point, the connection has be successfully connected.
+  // #REFCOUNT# is one.
+  if (TAO_debug_level > 2)
+    ACE_DEBUG ((LM_DEBUG,
+                "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                "new connection to <%s:%d> on Transport[%d]\n",
+                sciop_endpoint->host (), sciop_endpoint->port (),
+                svc_handler->peer ().get_handle ()));
+
+  TAO_Transport *transport =
+    svc_handler->transport ();
+
+  // Add the handler to Cache
+  int retval =
+    this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
+                                                                             transport);
+
+  // Failure in adding to cache.
+  if (retval != 0)
+    {
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                      "could not add the new connection to cache\n"));
+        }
+
+      return 0;
+    }
+
+  // Registration failures.
+  if (retval != 0)
+    {
+      // Purge from the connection cache.
+      transport->purge_entry ();
+
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "TAO (%P|%t) - SCIOP_Connector::make_connection, "
+                      "could not register the new connection in the reactor\n"));
+        }
+
+      return 0;
+    }
+
+  return transport;
+}
 
 TAO_Profile *
 TAO_SCIOP_Connector::create_profile (TAO_InputCDR& cdr)
diff --git a/TAO/tao/Strategies/SCIOP_Connector.h b/TAO/tao/Strategies/SCIOP_Connector.h
index 18be38def33..80ed607d268 100644
--- a/TAO/tao/Strategies/SCIOP_Connector.h
+++ b/TAO/tao/Strategies/SCIOP_Connector.h
@@ -91,6 +91,10 @@ protected:
                        TAO_Transport_Descriptor_Interface *desc,
                        ACE_Time_Value *timeout = 0);
 
+  TAO_Transport *make_connection (TAO::Profile_Transport_Resolver *r,
+                                  TAO_Transport_Descriptor_Interface &desc,
+                                  ACE_Time_Value *timeout = 0);
+
   /// More TAO_Connector methods, please check the documentation on
   /// Transport_Connector.h
   virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL);
diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp
index c85609dd5fa..25a971629cb 100644
--- a/TAO/tao/Strategies/SHMIOP_Connector.cpp
+++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp
@@ -280,6 +280,133 @@ TAO_SHMIOP_Connector::make_connection (TAO_GIOP_Invocation *invocation,
   return 0;
 }
 
+TAO_Transport *
+TAO_SHMIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
+                                       TAO_Transport_Descriptor_Interface &desc,
+                                       ACE_Time_Value *max_wait_time)
+{
+  if (TAO_debug_level > 0)
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("TAO (%P|%t) Connector::connect - ")
+                  ACE_TEXT ("looking for SHMIOP connection.\n")));
+
+  TAO_SHMIOP_Endpoint *shmiop_endpoint =
+    this->remote_endpoint (desc.endpoint ());
+
+  if (shmiop_endpoint == 0)
+    return 0;
+
+  const ACE_INET_Addr &remote_address =
+    shmiop_endpoint->object_addr ();
+
+  if (TAO_debug_level > 2)
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("(%P|%t) SHMIOP_Connector::connect ")
+                ACE_TEXT ("making a new connection \n")));
+
+  // Get the right synch options
+  ACE_Synch_Options synch_options;
+
+  this->active_connect_strategy_->synch_options (max_wait_time,
+                                                 synch_options);
+
+  TAO_SHMIOP_Connection_Handler *svc_handler = 0;
+
+  // Connect.
+  int result = this->base_connector_.connect (svc_handler,
+                                              remote_address,
+                                              synch_options);
+
+  // This call creates the service handler and bumps the #REFCOUNT# up
+  // one extra.  There are two possibilities: (a) connection succeeds
+  // immediately - in this case, the #REFCOUNT# on the handler is two;
+  // (b) connection fails immediately - in this case, the #REFCOUNT#
+  // on the handler is one since close() gets called on the handler.
+  // We always use a blocking connection so the connection is never
+  // pending.
+
+  // Irrespective of success or failure, remove the extra #REFCOUNT#.
+  svc_handler->remove_reference ();
+
+  // In case of errors.
+  if (result == -1)
+    {
+      // Give users a clue to the problem.
+      if (TAO_debug_level > 0)
+        {
+          ACE_DEBUG ((LM_ERROR,
+                      ACE_TEXT ("(%P|%t) %s:%u, connection to ")
+                      ACE_TEXT ("<%s:%p> failed (%p)\n"),
+                      __FILE__,
+                      __LINE__,
+                      shmiop_endpoint->host (),
+                      shmiop_endpoint->port (),
+                      ACE_TEXT ("errno")));
+        }
+
+      return 0;
+    }
+
+  // At this point, the connection has be successfully connected.
+  // #REFCOUNT# is one.
+  if (TAO_debug_level > 2)
+    ACE_DEBUG ((LM_DEBUG,
+                "TAO (%P|%t) - SHMIOP_Connector::make_connection, "
+                "new connection to <%s:%d> on Transport[%d]\n",
+                shmiop_endpoint->host (), shmiop_endpoint->port (),
+                svc_handler->peer ().get_handle ()));
+
+  TAO_Transport *transport =
+    svc_handler->transport ();
+
+  // Add the handler to Cache
+  int retval =
+    this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
+                                                                             transport);
+
+  // Failure in adding to cache.
+  if (retval != 0)
+    {
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "TAO (%P|%t) - SHMIOP_Connector::make_connection, "
+                      "could not add the new connection to cache\n"));
+        }
+
+      return 0;
+    }
+
+  // If the wait strategy wants us to be registered with the reactor
+  // then we do so. If registeration is required and it succeeds,
+  // #REFCOUNT# becomes two.
+  retval =  transport->wait_strategy ()->register_handler ();
+
+  // Registration failures.
+  if (retval != 0)
+    {
+      // Purge from the connection cache.
+      transport->purge_entry ();
+
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "TAO (%P|%t) - SHMIOP_Connector::make_connection, "
+                      "could not register the new connection in the reactor\n"));
+        }
+
+      return 0;
+    }
+
+  return transport;
+}
+
 TAO_Profile *
 TAO_SHMIOP_Connector::create_profile (TAO_InputCDR& cdr)
 {
diff --git a/TAO/tao/Strategies/SHMIOP_Connector.h b/TAO/tao/Strategies/SHMIOP_Connector.h
index e4891f1a64d..830259081dc 100644
--- a/TAO/tao/Strategies/SHMIOP_Connector.h
+++ b/TAO/tao/Strategies/SHMIOP_Connector.h
@@ -100,6 +100,10 @@ protected:
                        TAO_Transport_Descriptor_Interface *desc,
                        ACE_Time_Value *timeout = 0);
 
+  TAO_Transport *make_connection (TAO::Profile_Transport_Resolver *r,
+                                  TAO_Transport_Descriptor_Interface &desc,
+                                  ACE_Time_Value *timeout = 0);
+
   virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL);
   //@}
 
diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp
index 89dcdab3cbe..bb5bb554eb5 100644
--- a/TAO/tao/Strategies/UIOP_Connector.cpp
+++ b/TAO/tao/Strategies/UIOP_Connector.cpp
@@ -347,6 +347,216 @@ TAO_UIOP_Connector::make_connection (TAO_GIOP_Invocation *invocation,
   return 0;
 }
 
+TAO_Transport *
+TAO_UIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
+                                     TAO_Transport_Descriptor_Interface &desc,
+                                     ACE_Time_Value *max_wait_time)
+{
+  if (TAO_debug_level > 0)
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("TAO (%P|%t) Connector::connect - ")
+                ACE_TEXT ("looking for UIOP connection.\n")));
+
+  TAO_UIOP_Endpoint *uiop_endpoint =
+    this->remote_endpoint (desc.endpoint ());
+
+  if (uiop_endpoint == 0)
+    return 0;
+
+  const ACE_UNIX_Addr &remote_address =
+    uiop_endpoint->object_addr ();
+
+  if (TAO_debug_level > 2)
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("(%P|%t) UIOP_Connector::connect ")
+                ACE_TEXT ("making a new connection \n")));
+
+  // Get the right synch options
+  ACE_Synch_Options synch_options;
+
+  this->active_connect_strategy_->synch_options (max_wait_time,
+                                                 synch_options);
+
+  TAO_UIOP_Connection_Handler *svc_handler = 0;
+
+  // Connect.
+  int result =
+    this->base_connector_.connect (svc_handler,
+                                   remote_address,
+                                   synch_options);
+
+  // This call creates the service handler and bumps the #REFCOUNT# up
+  // one extra.  There are three possibilities: (a) connection
+  // succeeds immediately - in this case, the #REFCOUNT# on the
+  // handler is two; (b) connection completion is pending - in this
+  // case, the #REFCOUNT# on the handler is also two; (c) connection
+  // fails immediately - in this case, the #REFCOUNT# on the handler
+  // is one since close() gets called on the handler.
+  //
+  // The extra reference count in
+  // TAO_Connect_Creation_Strategy::make_svc_handler() is needed in
+  // the case when connection completion is pending and we are going
+  // to wait on a variable in the handler to changes, signifying
+  // success or failure.  Note, that this increment cannot be done
+  // once the connect() returns since this might be too late if
+  // another thread pick up the completion and potentially deletes the
+  // handler before we get a chance to increment the reference count.
+
+  // No immediate result.  Wait for completion.
+  if (result == -1 && errno == EWOULDBLOCK)
+    {
+      if (TAO_debug_level > 2)
+        ACE_DEBUG ((LM_DEBUG,
+                    "TAO (%P|%t) - UIOP_Connector::make_connection, "
+                    "going to wait for connection completion on local"
+                    "handle [%d]\n",
+                    svc_handler->get_handle ()));
+
+       // Wait for connection completion.  No need to specify timeout
+       // to wait() since the correct timeout was passed to the
+       // Connector. The Connector will close the handler in the case
+       // of timeouts, so the event will complete (either success or
+       // failure) within timeout.
+      result =
+        this->active_connect_strategy_->wait (svc_handler,
+                                              0);
+
+      if (TAO_debug_level > 2)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "TAO (%P|%t) - UIOP_Connector::make_connection"
+                      "wait done for handle[%d], result = %d\n",
+                      svc_handler->get_handle (), result));
+        }
+
+       // There are three possibilities when wait() returns: (a)
+       // connection succeeded; (b) connection failed; (c) wait()
+       // failed because of some other error.  It is easy to deal with
+       // (a) and (b).  (c) is tricky since the connection is still
+       // pending and may get completed by some other thread.  The
+       // following code deals with (c).
+
+       // Check if the handler has been closed.
+       int closed =
+         svc_handler->is_closed ();
+
+       // In case of failures and close() has not be called.
+       if (result == -1 &&
+           !closed)
+         {
+           // First, cancel from connector.
+           this->base_connector_.cancel (svc_handler);
+
+           // Double check to make sure the handler has not been
+           // closed yet.  This double check is required to ensure
+           // that the connection handler was not closed yet by some
+           // other thread since it was still registered with the
+           // connector.  Once connector.cancel() has been processed,
+           // we are assured that the connector will no longer
+           // open/close this handler.
+           closed =
+             svc_handler->is_closed ();
+
+           // If closed, there is nothing to do here.  If not closed,
+           // it was either opened or is still pending.
+           if (!closed)
+             {
+               // Check if the handler has been opened.
+               int open =
+                 svc_handler->is_open ();
+
+               // Some other thread was able to open the handler even
+               // though wait failed for this thread.
+               if (open)
+                 // Overwrite <result>.
+                 result = 0;
+               else
+                 {
+                   // Assert that it is still connecting.
+                   ACE_ASSERT (svc_handler->is_connecting ());
+
+                   // Force close the handler now.
+                   svc_handler->close ();
+                 }
+             }
+         }
+    }
+
+  // Irrespective of success or failure, remove the extra #REFCOUNT#.
+  svc_handler->remove_reference ();
+
+  // In case of errors.
+  if (result == -1)
+    {
+      // Give users a clue to the problem.
+      if (TAO_debug_level)
+        {
+          ACE_DEBUG ((LM_ERROR,
+                      ACE_TEXT ("(%P|%t) %s:%u, connection to ")
+                      ACE_TEXT ("%s failed (%p)\n"),
+                      __FILE__,
+                      __LINE__,
+                      uiop_endpoint->rendezvous_point (),
+                      ACE_TEXT ("errno")));
+        }
+
+      return 0;
+    }
+
+  // At this point, the connection has be successfully connected.
+  // #REFCOUNT# is one.
+
+  TAO_Transport *transport =
+    svc_handler->transport ();
+
+  // Add the handler to Cache
+  int retval =
+    this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
+                                                                             transport);
+  // Failure in adding to cache.
+  if (retval != 0)
+    {
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      ACE_TEXT ("(%P|%t) UIOP_Connector::connect ")
+                      ACE_TEXT ("could not add the new connection to Cache \n")));
+        }
+
+      return 0;
+    }
+
+  // If the wait strategy wants us to be registered with the reactor
+  // then we do so. If registeration is required and it succeeds,
+  // #REFCOUNT# becomes two.
+  retval = transport->wait_strategy ()->register_handler ();
+
+  // Registration failures.
+  if (retval != 0)
+    {
+      // Purge from the connection cache.
+      transport->purge_entry ();
+
+      // Close the handler.
+      svc_handler->close ();
+
+      if (TAO_debug_level > 0)
+        {
+          ACE_ERROR ((LM_ERROR,
+                      "TAO (%P|%t) - UIOP_Connector::make_connection, "
+                      "could not register the new connection in the reactor\n"));
+        }
+
+      return 0;
+    }
+
+  return transport;
+}
+
+
 TAO_Profile *
 TAO_UIOP_Connector::create_profile (TAO_InputCDR& cdr)
 {
diff --git a/TAO/tao/Strategies/UIOP_Connector.h b/TAO/tao/Strategies/UIOP_Connector.h
index fba3f439717..6aade9a8cfe 100644
--- a/TAO/tao/Strategies/UIOP_Connector.h
+++ b/TAO/tao/Strategies/UIOP_Connector.h
@@ -104,6 +104,10 @@ protected:
                        TAO_Transport_Descriptor_Interface *desc,
                        ACE_Time_Value *timeout = 0);
 
+  TAO_Transport *make_connection (TAO::Profile_Transport_Resolver *r,
+                                  TAO_Transport_Descriptor_Interface &desc,
+                                  ACE_Time_Value *timeout = 0);
+
   virtual TAO_Profile *make_profile (ACE_ENV_SINGLE_ARG_DECL);
 
   /// Obtains uiop properties that must be used by this connector, i.e.,
diff --git a/TAO/tao/Strategies/advanced_resource.cpp b/TAO/tao/Strategies/advanced_resource.cpp
index 80429c6ae87..c961fb4da36 100644
--- a/TAO/tao/Strategies/advanced_resource.cpp
+++ b/TAO/tao/Strategies/advanced_resource.cpp
@@ -33,6 +33,9 @@
 #include "ace/WFMO_Reactor.h"
 #include "ace/Msg_WFMO_Reactor.h"
 #include "ace/TP_Reactor.h"
+#include "ace/Memory_Pool.h"
+#include "ace/Null_Mutex.h"
+#include "ace/Malloc.h"
 
 ACE_RCSID(Strategies, advanced_resource, "$Id$")