TAO_Connection_Handler Class Reference

TAO_Connection_Handler. More...

#include <Connection_Handler.h>

Inheritance diagram for TAO_Connection_Handler:

[legend]Collaboration diagram for TAO_Connection_Handler:

[legend]List of all members.

Public Member Functions
	TAO_Connection_Handler (void)
	Constructor.
	TAO_Connection_Handler (TAO_ORB_Core *orb_core)
	Constructor.
virtual	~TAO_Connection_Handler (void)
	Destructor.
TAO_Transport *	transport (void)
	Return the underlying transport object.
void	transport (TAO_Transport *transport)
	Set the underlying transport object.
bool	is_closed (void) const
	Is the handler closed or timed out?
bool	is_open (void) const
	Is the handler open?
bool	is_timeout (void) const
	Closed due to timeout?
bool	is_connecting (void) const
	Is the handler in the process of being connected?
virtual int	close_connection (void)=0
	Close the underlying connection.
virtual int	handle_input (ACE_HANDLE fd)=0
int	svc_i (void)
virtual int	open_handler (void *)=0
	A open () hook.
virtual int	close_handler (void)
void	connection_pending (void)
void	cancel_pending_connection (void)
virtual int	set_dscp_codepoint (CORBA::Boolean set_network_priority)
virtual int	set_dscp_codepoint (CORBA::Long dscp_codepoint)
virtual int	release_os_resources (void)
	Release the OS resources related to this handler.
Protected Member Functions
TAO_ORB_Core *	orb_core (void)
	Return our TAO_ORB_Core pointer.
int	shared_open (void)
int	set_socket_option (ACE_SOCK &sock, int snd_size, int rcv_size)
	Set options on the socket.
Helper methods for Event_Handler-based derived classes.
Many (actually all so far) implementations of TAO_Connection_Handler are a mixin of TAO_Connection_Handler and some form of ACE_Event_Handler. The following methods simplify such implementations by capturing the common code in a single place.
int	handle_output_eh (ACE_HANDLE h, ACE_Event_Handler *eh)
	Implement the handle_output() callback.
int	handle_input_eh (ACE_HANDLE h, ACE_Event_Handler *eh)
	Implement the handle_input() callback.
int	handle_input_internal (ACE_HANDLE h, ACE_Event_Handler *eh)
	Implement the handle_output() callback.
int	close_connection_eh (ACE_Event_Handler *eh)
virtual void	pre_io_hook (int &return_value)
virtual void	pos_io_hook (int &return_value)
Private Attributes
TAO_ORB_Core *const	orb_core_
	Pointer to the TAO_ORB_Core.
TAO_Transport *	transport_
	Transport object reference.
ACE_Lock *	lock_
bool	connection_pending_
	Stores the connection pending state.

---

Detailed Description

TAO_Connection_Handler.

This class is an abstraction for the connection handlers. The connections handler in every protocol can derive from this class as well as the ACE_Svc_Handler specialised for the right protocol. This way, most of the common code for the different protocols would be in this implementation.

Definition at line 56 of file Connection_Handler.h.

---

Constructor & Destructor Documentation

TAO_Connection_Handler::TAO_Connection_Handler

(

void

)

Constructor.

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Connection_Handler::TAO_Connection_Handler

(

TAO_ORB_Core *

orb_core

)

Constructor.

Definition at line 26 of file Connection_Handler.cpp.

References TAO_LF_Event::LFS_CONNECTION_WAIT.

  : orb_core_ (orb_core),
    transport_ (0),
    connection_pending_ (false)
{
  // @todo: We need to have a distinct option/ method in the resource
  // factory for this and TAO_Transport.
  this->lock_ =
    this->orb_core_->resource_factory ()->create_cached_connection_lock ();

  // Put ourselves in the connection wait state as soon as we get
  // created
  this->state_changed (TAO_LF_Event::LFS_CONNECTION_WAIT,
                       this->orb_core_->leader_follower ());
}

TAO_Connection_Handler::~TAO_Connection_Handler

(

void

)

[virtual]

Destructor.

Definition at line 42 of file Connection_Handler.cpp.

References lock_.

{
  // @@ TODO Use auto_ptr<>
  delete this->lock_;

  //@@ CONNECTION_HANDLER_DESTRUCTOR_ADD_HOOK
}

---

Member Function Documentation

ACE_INLINE void TAO_Connection_Handler::cancel_pending_connection

(

void

)

A pending connection may be canceled due to an error detected while the initiating thread is still in the Connector.

Definition at line 58 of file Connection_Handler.inl.

References connection_pending_, TAO_Transport::remove_reference(), and transport().

Referenced by TAO_IIOP_Connector::complete_connection(), and shared_open().

{
  if (this->connection_pending_)
    {
      this->connection_pending_ = false;
      this->transport()->remove_reference();
    }
}

virtual int TAO_Connection_Handler::close_connection

(

void

)

[pure virtual]

Close the underlying connection.

Used by the ORB to actively close connections that are idle, stale or somehow are determined to be broken before the Reactor does.

Returns:

Return 0 if the connection was already closed, non-zero otherwise.

Implemented in TAO_IIOP_Connection_Handler.

Referenced by TAO_Transport::close_connection(), handle_input_eh(), and TAO_Thread_Per_Connection_Handler::~TAO_Thread_Per_Connection_Handler().

int TAO_Connection_Handler::close_connection_eh

(

ACE_Event_Handler *

eh

)

[protected]

Implement close_connection() for Connection_Handlers that are also Event_Handlers.

Definition at line 296 of file Connection_Handler.cpp.

References ACE_ASSERT, ACE_DEBUG, ACE_Event_Handler::ALL_EVENTS_MASK, ACE_Event_Handler::DONT_CALL, ACE_Event_Handler::get_handle(), TAO_Transport::id(), TAO_Wait_Strategy::is_registered(), TAO_LF_Event::LFS_CONNECTION_CLOSED, LM_DEBUG, TAO_Transport::orb_core(), TAO_Transport::pre_close(), TAO_ORB_Core::reactor(), ACE_Event_Handler::reactor(), TAO_Transport::send_connection_closed_notifications(), TAO_LF_Event::state_changed(), TAO_debug_level, transport(), and TAO_Transport::wait_strategy().

Referenced by TAO_IIOP_Connection_Handler::close_connection().

{
  // Save the ID for debugging messages
  ACE_HANDLE handle = eh->get_handle ();

  size_t const id = this->transport ()->id ();
  if (TAO_debug_level)
    {
      ACE_DEBUG  ((LM_DEBUG,
                   "TAO (%P|%t) - Connection_Handler[%d]::"
                   "close_connection_eh, purging entry from cache\n",
                   handle));
    }

  this->transport ()->pre_close ();

  // @@ This seems silly, but if we have no reason to be in the
  // reactor, then we dont remove ourselves.
  if (this->transport ()->wait_strategy ()->is_registered ())
    {
      ACE_Reactor *eh_reactor = eh->reactor ();

      if (this->orb_core_->has_shutdown () == 0)
        {
          // If the ORB is nil, get the reactor from orb_core which gets it
          // from LF.
          if (eh_reactor == 0)
            eh_reactor = this->transport()->orb_core()->reactor ();
        }

      // The Reactor must not be null, otherwise something else is
      // horribly broken.
      ACE_ASSERT (eh_reactor != 0);

      if (TAO_debug_level)
        {
          ACE_DEBUG  ((LM_DEBUG,
                       "TAO (%P|%t) - Connection_Handler[%d]::"
                       "close_connection_eh, removing from the reactor\n",
                       handle));
        }

      // Use id instead of handle. Why? "handle" may be invalid for RW
      // cases  when drop_reply_on_shutdown is on, and when the
      // orb_core is shutting down. This means that the handler will
      // be left behind in the reactor which would create problems
      // later. Just forcefully remove them. If none exists reactor
      // will make things safer.
      ACE_HANDLE tmp_handle = handle;
      if (this->orb_core_->has_shutdown ())
        tmp_handle = (ACE_HANDLE) id;

      eh_reactor->remove_handler (tmp_handle,
                                  ACE_Event_Handler::ALL_EVENTS_MASK |
                                  ACE_Event_Handler::DONT_CALL);

      // Also cancel any timers, we may create those for time-limited
      // buffering
      if (TAO_debug_level)
        {
          ACE_DEBUG  ((LM_DEBUG,
                       "TAO (%P|%t) - Connection_Handler[%d]::"
                       "close_connection_eh, cancel all timers\n",
                       handle));
        }

      eh_reactor->cancel_timer (eh);

      // @@ This seems silly, the reactor is a much better authority to
      //    find out if a handle is registered...
      this->transport ()->wait_strategy ()->is_registered (false);
    }

  // This call should be made only after the cache and reactor are
  // cleaned up. This call can make upcalls to the application which
  // in turn can make remote calls (Bug 1551 and Bug 1482). The remote
  // calls from the application can try to use this handler from the
  // cache or from the reactor. So clean them up before this is
  // called.
  this->transport ()->send_connection_closed_notifications ();
  this->state_changed (TAO_LF_Event::LFS_CONNECTION_CLOSED,
                       this->orb_core_->leader_follower ());

  if (TAO_debug_level)
    {
      ACE_DEBUG  ((LM_DEBUG,
                   "TAO (%P|%t) - Connection_Handler[%d]::"
                   "close_connection_eh\n",
                   id));
    }

  return 1;
}

int TAO_Connection_Handler::close_handler

(

void

)

[virtual]

A close() hook, called by the Transport Connector when they want to close this handler

Definition at line 430 of file Connection_Handler.cpp.

References TAO_LF_Event::LFS_CONNECTION_CLOSED, TAO_Transport::purge_entry(), TAO_Transport::remove_reference(), TAO_LF_Event::state_changed(), and transport().

Referenced by TAO_IIOP_Connection_Handler::close().

{
  this->state_changed (TAO_LF_Event::LFS_CONNECTION_CLOSED,
                       this->orb_core_->leader_follower ());
  this->transport ()->purge_entry();
  this->transport ()->remove_reference ();

  // @@ I think that if the connection_pending state is true
  // when close_handler is calld, we should probably release
  // another reference so that the connector doesn't have to
  // worry about it.

  return 0;
}

ACE_INLINE void TAO_Connection_Handler::connection_pending

(

void

)

When waiting for an asynchronous connection to complete an additional reference must be maintained, related to bugzilla #2417. However once the connection is successfully established, this reference must be removed. Using connection_pending allows the connection handler to know that it is opening as a result of a delayed asynch connection rather than an immediate synch connection, which has no additional reference needs.

Definition at line 48 of file Connection_Handler.inl.

References TAO_Transport::add_reference(), connection_pending_, and transport().

Referenced by TAO_IIOP_Connector::complete_connection().

{
  if (!this->connection_pending_)
    {
      this->connection_pending_ = true;
      this->transport()->add_reference();
    }
}

virtual int TAO_Connection_Handler::handle_input

(

ACE_HANDLE

fd

)

[pure virtual]

The event handler calls, here so that other objects who hold a reference to this object can call the event handler methods.

Implemented in TAO_IIOP_Connection_Handler.

int TAO_Connection_Handler::handle_input_eh	(	ACE_HANDLE	h,
		ACE_Event_Handler *	eh
	)			[protected]

Implement the handle_input() callback.

Definition at line 217 of file Connection_Handler.cpp.

References ACE_DEBUG, close_connection(), handle_input_internal(), LM_DEBUG, and TAO_debug_level.

Referenced by TAO_IIOP_Connection_Handler::handle_input().

{
  // If we can't process upcalls just return
  if (!this->transport ()->wait_strategy ()->can_process_upcalls ())
    {
      if (TAO_debug_level > 6)
        ACE_DEBUG ((LM_DEBUG,
                    "TAO (%P|%t) - Connection_Handler[%d]::handle_input_eh, "
                    "not going to handle_input on transport "
                    "because upcalls temporarily suspended on this thread\n",
                    this->transport()->id()));
      return 0;
    }

  int const result = this->handle_input_internal (h, eh);

  if (result == -1)
    {
      this->close_connection ();
      return 0;
    }

  return result;
}

int TAO_Connection_Handler::handle_input_internal	(	ACE_HANDLE	h,
		ACE_Event_Handler *	eh
	)			[protected]

Implement the handle_output() callback.

Definition at line 244 of file Connection_Handler.cpp.

References ACE_DEBUG, ACE_Event_Handler::get_handle(), TAO_Transport::handle_input(), TAO_Transport::id(), LM_DEBUG, pos_io_hook(), pre_io_hook(), TAO_debug_level, TAO_Resume_Handle::TAO_HANDLE_LEAVE_SUSPENDED, and transport().

Referenced by handle_input_eh().

{
  // Let the transport know that it is used
  (void) this->transport ()->update_transport ();

  // Grab the transport id now and use the cached value for printing
  // since the  transport could dissappear by the time the thread
  // returns.
  size_t const t_id =
    this->transport ()->id ();

  if (TAO_debug_level > 6)
    {
      ACE_HANDLE handle = eh->get_handle();
      ACE_DEBUG ((LM_DEBUG,
                  "TAO (%P|%t) - Connection_Handler[%d]::handle_input, "
                  "handle = %d/%d\n",
                  t_id, handle, h));
    }

  TAO_Resume_Handle resume_handle (this->orb_core (), eh->get_handle ());

  int return_value = 0;

  this->pre_io_hook (return_value);
  if (return_value != 0)
    return return_value;

  return_value = this->transport ()->handle_input (resume_handle);

  this->pos_io_hook (return_value);

  // Bug 1647; might need to change resume_handle's flag or
  // change handle_input return value.
  resume_handle.handle_input_return_value_hook(return_value);

  if (TAO_debug_level > 6)
    {
      ACE_HANDLE handle = eh->get_handle ();
      ACE_DEBUG ((LM_DEBUG,
                  "TAO (%P|%t) - Connection_Handler[%d]::handle_input, "
                  "handle = %d/%d, retval = %d\n",
                  t_id, handle, h, return_value));
    }

  if (return_value == -1)
    resume_handle.set_flag (TAO_Resume_Handle::TAO_HANDLE_LEAVE_SUSPENDED);
  return return_value;
}

int TAO_Connection_Handler::handle_output_eh	(	ACE_HANDLE	h,
		ACE_Event_Handler *	eh
	)			[protected]

Implement the handle_output() callback.

Definition at line 185 of file Connection_Handler.cpp.

References ACE_Event_Handler::get_handle(), TAO_Transport::handle_output(), pos_io_hook(), pre_io_hook(), TAO_Resume_Handle::TAO_HANDLE_LEAVE_SUSPENDED, and transport().

Referenced by TAO_IIOP_Connection_Handler::handle_output().

{
  // Let the transport that it is going to be used
  (void) this->transport ()->update_transport ();

  // Instantiate the resume handle here.. This will automatically
  // resume the handle once data is written..
  TAO_Resume_Handle resume_handle (this->orb_core (),
                                   eh->get_handle ());

  int return_value = 0;
  this->pre_io_hook (return_value);
  if (return_value != 0)
    {
      resume_handle.set_flag (TAO_Resume_Handle::TAO_HANDLE_LEAVE_SUSPENDED);
      return return_value;
    }

  return_value = this->transport ()->handle_output (0);

  this->pos_io_hook (return_value);

  if (return_value != 0)
    {
      resume_handle.set_flag (TAO_Resume_Handle::TAO_HANDLE_LEAVE_SUSPENDED);
    }

  return return_value;
}

ACE_INLINE bool TAO_Connection_Handler::is_closed

(

void

)

const

Is the handler closed or timed out?

Definition at line 22 of file Connection_Handler.inl.

References TAO_LF_Event::LFS_CONNECTION_CLOSED, and TAO_LF_Event::LFS_TIMEOUT.

Referenced by TAO_Connector::check_connection_closure(), and TAO_Connector::wait_for_connection_completion().

{
  return (this->state_ == TAO_LF_Event::LFS_CONNECTION_CLOSED ||
          this->state_ == TAO_LF_Event::LFS_TIMEOUT);
}

ACE_INLINE bool TAO_Connection_Handler::is_connecting

(

void

)

const

Is the handler in the process of being connected?

Definition at line 41 of file Connection_Handler.inl.

References TAO_LF_Event::LFS_CONNECTION_WAIT, and TAO_LF_Event::state_.

{
  return this->state_ == TAO_LF_Event::LFS_CONNECTION_WAIT;
}

ACE_INLINE bool TAO_Connection_Handler::is_open

(

void

)

const

Is the handler open?

Definition at line 35 of file Connection_Handler.inl.

References TAO_LF_Event::LFS_SUCCESS, and TAO_LF_Event::state_.

Referenced by TAO_Connector::wait_for_connection_completion().

{
  return this->state_ == TAO_LF_Event::LFS_SUCCESS;
}

ACE_INLINE bool TAO_Connection_Handler::is_timeout

(

void

)

const

Closed due to timeout?

Definition at line 29 of file Connection_Handler.inl.

References TAO_LF_Event::LFS_TIMEOUT.

Referenced by TAO_Connector::wait_for_connection_completion().

{
  return (this->state_ == TAO_LF_Event::LFS_TIMEOUT);
}

virtual int TAO_Connection_Handler::open_handler

(

void *

)

[pure virtual]

A open () hook.

See Thread_Per_Connection_Handler for a use case

Implemented in TAO_IIOP_Connection_Handler.

Referenced by TAO_Thread_Per_Connection_Handler::open().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE TAO_ORB_Core * TAO_Connection_Handler::orb_core

(

void

)

[protected]

Return our TAO_ORB_Core pointer.

Definition at line 10 of file Connection_Handler.inl.

References orb_core_.

Referenced by TAO_IIOP_Connection_Handler::add_transport_to_cache(), TAO_IIOP_Connection_Handler::close_connection(), TAO_IIOP_Connection_Handler::open(), TAO_IIOP_Connection_Handler::set_dscp_codepoint(), and TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler().

{
  return this->orb_core_;
}

void TAO_Connection_Handler::pos_io_hook

(

int &

return_value

)

[protected, virtual]

See the SSLIOP protocol for an interesting use-case

Definition at line 425 of file Connection_Handler.cpp.

Referenced by handle_input_internal(), and handle_output_eh().

{
}

void TAO_Connection_Handler::pre_io_hook

(

int &

return_value

)

[protected, virtual]

See the SSLIOP protocol for an interesting use-case

Definition at line 420 of file Connection_Handler.cpp.

Referenced by handle_input_internal(), and handle_output_eh().

{
}

int TAO_Connection_Handler::release_os_resources

(

void

)

[virtual]

Release the OS resources related to this handler.

Reimplemented in TAO_IIOP_Connection_Handler.

Definition at line 412 of file Connection_Handler.cpp.

{
  return 0;
}

int TAO_Connection_Handler::set_dscp_codepoint

(

CORBA::Long

dscp_codepoint

)

[virtual]

Reimplemented in TAO_IIOP_Connection_Handler.

Definition at line 406 of file Connection_Handler.cpp.

{
  return 0;
}

int TAO_Connection_Handler::set_dscp_codepoint

(

CORBA::Boolean

set_network_priority

)

[virtual]

Set the Diff-Serv codepoint on outgoing packets. Only has effect for remote protocols (e.g., IIOP); no effect for local protocols (UIOP). Default implementation is for local protocols. Remote protocols must overwrite implementation.

Reimplemented in TAO_IIOP_Connection_Handler.

Definition at line 400 of file Connection_Handler.cpp.

Referenced by TAO::Remote_Invocation::send_message().

{
  return 0;
}

int TAO_Connection_Handler::set_socket_option	(	ACE_SOCK &	sock,
		int	snd_size,
		int	rcv_size
	)			[protected]

Set options on the socket.

Definition at line 64 of file Connection_Handler.cpp.

References ACE_CLOEXEC, ACE_IPC_SAP::enable(), ENOTSUP, ACE_SOCK::set_option(), SO_RCVBUF, SO_SNDBUF, and SOL_SOCKET.

{
#if !defined (ACE_LACKS_SOCKET_BUFSIZ)

  if (snd_size != 0
      && sock.set_option (SOL_SOCKET,
                          SO_SNDBUF,
                          (void *) &snd_size,
                          sizeof (snd_size)) == -1
      && errno != ENOTSUP)
  {
    return -1;
  }

  if (rcv_size != 0
      && sock.set_option (SOL_SOCKET,
                          SO_RCVBUF,
                          (void *) &rcv_size,
                          sizeof (int)) == -1
      && errno != ENOTSUP)
  {
    return -1;
  }
#else
   ACE_UNUSED_ARG (snd_size);
   ACE_UNUSED_ARG (rcv_size);
#endif /* !ACE_LACKS_SOCKET_BUFSIZ */

  // Set the close-on-exec flag for that file descriptor. If the
  // operation fails we are out of luck (some platforms do not support
  // it and return -1).
  (void) sock.enable (ACE_CLOEXEC);

  return 0;
}

int TAO_Connection_Handler::shared_open

(

void

)

[protected]

A common function called at the start of any protocol-specific open. Returns -1 on a failure (although no failure mode is currently defined).

Definition at line 51 of file Connection_Handler.cpp.

References cancel_pending_connection().

{
  // This reference counting is related to asynch connections.  It
  // should probably be managed by the ACE_Strategy_Connector, since
  // that's really the reference being managed here.  also, whether
  // open ultimately succeeds or fails, the connection attempted is
  // ending, so the reference must be removed in any case.
  this->cancel_pending_connection();

  return 0;
}

int TAO_Connection_Handler::svc_i

(

void

)

This method is invoked from the svc () method of the Svc_Handler Object.

Definition at line 103 of file Connection_Handler.cpp.

References ACE_DEBUG, ACE_TEXT, TAO_Transport::handle_input(), LM_DEBUG, ACE_Time_Value::msec(), TAO_debug_level, transport(), and TAO_Transport::update_transport().

Referenced by TAO_Thread_Per_Connection_Handler::svc().

{
  int result = 0;

  if (TAO_debug_level > 0)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("TAO (%P|%t) - Connection_Handler::svc_i begin\n")));

  // Here we simply synthesize the "typical" event loop one might find
  // in a reactive handler, except that this can simply block waiting
  // for input.

  ACE_Time_Value *max_wait_time = 0;
  ACE_Time_Value timeout;
  ACE_Time_Value current_timeout;

  if (this->orb_core_->thread_per_connection_timeout (timeout))
    {
      current_timeout = timeout;
      max_wait_time = &current_timeout;
    }

  TAO_Resume_Handle rh (this->orb_core_,
                        ACE_INVALID_HANDLE);

  // We exit of the loop if
  // - If the ORB core is shutdown by another thread
  // - Or if the transport is null. This could happen if an error
  // occured.
  // - Or if during processing a return value of -1 is received.
  while (!this->orb_core_->has_shutdown ()
         && result >= 0)
    {
      // Let the transport know that it is used
      (void) this->transport ()->update_transport ();

      result = this->transport ()->handle_input (rh, max_wait_time);

      if (result == -1 && errno == ETIME)
        {
          // Ignore timeouts, they are only used to wake up and
          // shutdown.
          result = 0;

          // Reset errno to make sure we don't trip over an old value
          // of errno in case it is not reset when the recv() call
          // fails if the socket has been closed.
          errno = 0;
        }
      else if (result == -1)
        {
          // Something went wrong with the socket. Just quit
          return result;
        }

      current_timeout = timeout;

      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    "TAO (%P|%t) - Connection_Handler::svc_i - "
                    "loop <%d>\n", current_timeout.msec ()));
    }

  if (TAO_debug_level > 0)
    ACE_DEBUG  ((LM_DEBUG,
                 "TAO (%P|%t) - Connection_Handler::svc_i end\n"));

  return result;
}

void TAO_Connection_Handler::transport

(

TAO_Transport *

transport

)

Set the underlying transport object.

Definition at line 174 of file Connection_Handler.cpp.

References ACE_Event_Handler::Reference_Counting_Policy::ENABLED, TAO_Transport::event_handler_i(), ACE_Event_Handler::reference_counting_policy(), transport(), and transport_.

{
  this->transport_ = transport;

  // Enable reference counting on the event handler.
  this->transport_->event_handler_i ()->reference_counting_policy ().value (
      ACE_Event_Handler::Reference_Counting_Policy::ENABLED
    );
}

ACE_INLINE TAO_Transport * TAO_Connection_Handler::transport

(

void

)

Return the underlying transport object.

Definition at line 16 of file Connection_Handler.inl.

References transport_.

Referenced by TAO_LF_Multi_Event::base_transport(), cancel_pending_connection(), close_connection_eh(), close_handler(), connection_pending(), handle_input_internal(), handle_output_eh(), TAO_IIOP_Connection_Handler::open(), TAO_IIOP_Connection_Handler::process_listen_point_list(), svc_i(), TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler(), transport(), TAO_Connect_Strategy::wait(), TAO_Connector::wait_for_connection_completion(), TAO_IIOP_Connection_Handler::~TAO_IIOP_Connection_Handler(), and TAO_Thread_Per_Connection_Handler::~TAO_Thread_Per_Connection_Handler().

{
  return this->transport_;
}

---

Member Data Documentation

bool TAO_Connection_Handler::connection_pending_ [private]

Stores the connection pending state.

Definition at line 212 of file Connection_Handler.h.

Referenced by cancel_pending_connection(), and connection_pending().

ACE_Lock* TAO_Connection_Handler::lock_ [private]

Internal state lock, needs to be separate from the reference count / pending upcalls lock because they interleave.

Definition at line 209 of file Connection_Handler.h.

Referenced by ~TAO_Connection_Handler().

TAO_ORB_Core* const TAO_Connection_Handler::orb_core_ [private]

Pointer to the TAO_ORB_Core.

Definition at line 202 of file Connection_Handler.h.

Referenced by orb_core().

TAO_Transport* TAO_Connection_Handler::transport_ [private]

Transport object reference.

Definition at line 205 of file Connection_Handler.h.

Referenced by transport().

---

The documentation for this class was generated from the following files:

• Connection_Handler.h
• Connection_Handler.cpp
• Connection_Handler.inl

---