TAO_DIOP_Connector Class Reference

DIOP-specific Connector bridge for pluggable protocols. More...

#include <DIOP_Connector.h>

Inheritance diagram for TAO_DIOP_Connector:

[legend]Collaboration diagram for TAO_DIOP_Connector:

[legend]List of all members.

Public Member Functions
	TAO_DIOP_Connector (void)
	Constructor.
	~TAO_DIOP_Connector (void)
	Destructor.
The TAO_Connector Methods
Please check the documentation in Transport_Connector.h for details.
int	open (TAO_ORB_Core *orb_core)
int	close (void)
TAO_Profile *	create_profile (TAO_InputCDR &cdr)
virtual int	check_prefix (const char *endpoint)
virtual char	object_key_delimiter (void) const
Protected Member Functions
int	cancel_svc_handler (TAO_Connection_Handler *svc_handler)
	Cancel the passed cvs handler from the connector.
More TAO_Connector Methods
Please check the documentation in Transport_Connector.h for details.
int	set_validate_endpoint (TAO_Endpoint *ep)
TAO_Transport *	make_connection (TAO::Profile_Transport_Resolver *r, TAO_Transport_Descriptor_Interface &desc, ACE_Time_Value *timeout=0)
virtual TAO_Profile *	make_profile (void)
Private Member Functions
TAO_DIOP_Endpoint *	remote_endpoint (TAO_Endpoint *ep)
	Return the remote endpoint, a helper function.

---

Detailed Description

DIOP-specific Connector bridge for pluggable protocols.

Concrete instance of the TAO_Connector class. Responsible for establishing a connection with a server and is called from the Connector_Registory.

Definition at line 47 of file DIOP_Connector.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_DIOP_Connector::TAO_DIOP_Connector

(

void

)

Constructor.

Definition at line 30 of file DIOP_Connector.cpp.

  : TAO_Connector (TAO_TAG_DIOP_PROFILE)
{
}

TAO_DIOP_Connector::~TAO_DIOP_Connector

(

void

)

Destructor.

Definition at line 35 of file DIOP_Connector.cpp.

{
}

---

Member Function Documentation

int TAO_DIOP_Connector::cancel_svc_handler

(

TAO_Connection_Handler *

svc_handler

)

[protected, virtual]

Cancel the passed cvs handler from the connector.

Implements TAO_Connector.

Definition at line 299 of file DIOP_Connector.cpp.

{
  return 0;
}

int TAO_DIOP_Connector::check_prefix

(

const char *

endpoint

)

[virtual]

Implements TAO_Connector.

Definition at line 256 of file DIOP_Connector.cpp.

References ACE_OS::strchr(), ACE_OS::strlen(), and ACE_OS::strncasecmp().

{
  // Check for a valid string
  if (!endpoint || !*endpoint)
    return -1;  // Failure

  const char *protocol[] = { "diop", "dioploc" };

  size_t const slot = ACE_OS::strchr (endpoint, ':') - endpoint;

  size_t const len0 = ACE_OS::strlen (protocol[0]);
  size_t const len1 = ACE_OS::strlen (protocol[1]);

  // Check for the proper prefix in the IOR.  If the proper prefix
  // isn't in the IOR then it is not an IOR we can use.
  if (slot == len0
      && ACE_OS::strncasecmp (endpoint, protocol[0], len0) == 0)
    return 0;
  else if (slot == len1
           && ACE_OS::strncasecmp (endpoint, protocol[1], len1) == 0)
    return 0;

  return -1;
  // Failure: not an DIOP IOR
  // DO NOT throw an exception here.
}

int TAO_DIOP_Connector::close

(

void

)

[virtual]

Implements TAO_Connector.

Definition at line 52 of file DIOP_Connector.cpp.

{
  return 0;
}

TAO_Profile * TAO_DIOP_Connector::create_profile

(

TAO_InputCDR &

cdr

)

[virtual]

Implements TAO_Connector.

Definition at line 219 of file DIOP_Connector.cpp.

References TAO_Profile::_decr_refcnt(), ACE_NEW_RETURN, and TAO_Profile::decode().

{
  TAO_Profile *pfile = 0;
  ACE_NEW_RETURN (pfile,
                  TAO_DIOP_Profile (this->orb_core ()),
                  0);

  if (pfile->decode (cdr) == -1)
    {
      pfile->_decr_refcnt ();
      pfile = 0;
    }

  return pfile;
}

TAO_Transport * TAO_DIOP_Connector::make_connection	(	TAO::Profile_Transport_Resolver *	r,
		TAO_Transport_Descriptor_Interface &	desc,
		ACE_Time_Value *	timeout = 0
	)			[protected, virtual]

Implements TAO_Connector.

Definition at line 95 of file DIOP_Connector.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_NEW_RETURN, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, TAO_DIOP_Connection_Handler::addr(), ACE_INET_Addr::addr_to_string(), TAO_DIOP_Connection_Handler::close(), TAO_Transport_Descriptor_Interface::endpoint(), ACE_Addr::get_type(), TAO_DIOP_Endpoint::host(), INADDR_ANY, TAO_ORB_Core::lane_resources(), LM_DEBUG, LM_ERROR, TAO_DIOP_Connection_Handler::local_addr(), MAXHOSTNAMELEN, TAO_DIOP_Endpoint::object_addr(), TAO_DIOP_Connection_Handler::open(), TAO_Connector::orb_core(), ACE_Svc_Handler<, >::peer(), TAO_DIOP_Endpoint::port(), remote_endpoint(), ACE_INET_Addr::set(), TAO_debug_level, TAO_Connection_Handler::transport(), and TAO_Thread_Lane_Resources::transport_cache().

{
  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 ();

#if defined (ACE_HAS_IPV6) && !defined (ACE_HAS_IPV6_V6ONLY)
  // Check if we need to invalidate accepted connections
  // from IPv4 mapped IPv6 addresses
  if (this->orb_core ()->orb_params ()->connect_ipv6_only () &&
      remote_address.is_ipv4_mapped_ipv6 ())
    {
      if (TAO_debug_level > 0)
        {
          ACE_TCHAR remote_as_string[MAXHOSTNAMELEN + 16];

          (void) remote_address.addr_to_string (remote_as_string,
                                                sizeof remote_as_string);

          ACE_ERROR ((LM_ERROR,
                      ACE_TEXT ("TAO (%P|%t) - DIOP_Connection_Handler::open, ")
                      ACE_TEXT ("invalid connection to IPv4 mapped IPv6 interface <%s>!\n"),
                      remote_as_string));
        }
      return 0;
    }
#endif /* ACE_HAS_IPV6 && ACE_HAS_IPV6_V6ONLY */

  TAO_DIOP_Connection_Handler *svc_handler = 0;

  ACE_NEW_RETURN (svc_handler,
                  TAO_DIOP_Connection_Handler (this->orb_core ()),
                  0);

  u_short port = 0;
  const ACE_UINT32 ia_any = INADDR_ANY;
  ACE_INET_Addr local_addr (port, ia_any);

#if defined (ACE_HAS_IPV6)
  if (remote_address.get_type () == AF_INET6)
    local_addr.set (port,
                    ACE_IPV6_ANY);
#endif /* ACE_HAS_IPV6 */

  svc_handler->local_addr (local_addr);
  svc_handler->addr (remote_address);

  int retval = svc_handler->open (0);

  // Failure to open a connection.
  if (retval != 0)
    {
      // Close the handler (this will also delete svc_handler).
      svc_handler->close ();

      if (TAO_debug_level > 0)
        {
          ACE_ERROR ((LM_ERROR,
                      ACE_TEXT ("TAO (%P|%t) - DIOP_Connector::make_connection, ")
                      ACE_TEXT ("could not make a new connection\n")));
        }

      return 0;
    }

  if (TAO_debug_level > 2)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("TAO (%P|%t) - DIOP_Connector::connect, ")
                ACE_TEXT ("new connection on HANDLE %d\n"),
                svc_handler->peer ().get_handle ()));

  TAO_DIOP_Transport *transport =
    dynamic_cast <TAO_DIOP_Transport *> (svc_handler->transport ());

  // In case of errors transport is zero
  if (transport == 0)
    {
      // Close the handler (this will also delete svc_handler).
      svc_handler->close ();

      // Give users a clue to the problem.
      if (TAO_debug_level > 3)
        ACE_DEBUG ((LM_ERROR,
                    ACE_TEXT ("TAO (%P|%t) - DIOP_Connector::make_connection, ")
                    ACE_TEXT ("connection to <%s:%u> failed (%p)\n"),
                    ACE_TEXT_CHAR_TO_TCHAR (diop_endpoint->host ()),
                    diop_endpoint->port (),
                    ACE_TEXT ("errno")));

      return 0;
    }

  // Add the handler to Cache
  retval =
    this->orb_core ()->lane_resources ().transport_cache ().cache_transport (&desc,
                                                                             transport);

  // Failure in adding to cache.
  if (retval != 0)
    {
      // Close the handler (this will also delete svc_handler).
      svc_handler->close ();

      if (TAO_debug_level > 0)
        {
          ACE_ERROR ((LM_ERROR,
                      ACE_TEXT ("TAO (%P|%t) - DIOP_Connector::make_connection, ")
                      ACE_TEXT ("could not add the new connection to cache\n")));
        }

      return 0;
    }

  return transport;
}

TAO_Profile * TAO_DIOP_Connector::make_profile

(

void

)

[protected, virtual]

Implements TAO_Connector.

Definition at line 236 of file DIOP_Connector.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_NEW_THROW_EX, CORBA::COMPLETED_NO, and TAO::VMCID.

{
  // The endpoint should be of the form:
  //    N.n@host:port/object_key
  // or:
  //    host:port/object_key

  TAO_Profile *profile = 0;
  ACE_NEW_THROW_EX (profile,
                    TAO_DIOP_Profile (this->orb_core ()),
                    CORBA::NO_MEMORY (
                      CORBA::SystemException::_tao_minor_code (
                        TAO::VMCID,
                        ENOMEM),
                      CORBA::COMPLETED_NO));

  return profile;
}

char TAO_DIOP_Connector::object_key_delimiter

(

void

)

const [virtual]

Implements TAO_Connector.

Definition at line 284 of file DIOP_Connector.cpp.

References TAO_DIOP_Profile::object_key_delimiter_.

{
  return TAO_DIOP_Profile::object_key_delimiter_;
}

int TAO_DIOP_Connector::open

(

TAO_ORB_Core *

orb_core

)

[virtual]

Implements TAO_Connector.

Definition at line 40 of file DIOP_Connector.cpp.

References TAO_Connector::orb_core().

{
  this->orb_core (orb_core);

  // Create our connect strategy
  if (this->create_connect_strategy () == -1)
    return -1;

  return 0;
}

TAO_DIOP_Endpoint * TAO_DIOP_Connector::remote_endpoint

(

TAO_Endpoint *

ep

)

[private]

Return the remote endpoint, a helper function.

Definition at line 290 of file DIOP_Connector.cpp.

References TAO_Endpoint::tag(), and TAO_TAG_DIOP_PROFILE.

Referenced by make_connection(), and set_validate_endpoint().

{
  if (endpoint->tag () != TAO_TAG_DIOP_PROFILE)
    return 0;

  return dynamic_cast<TAO_DIOP_Endpoint *> (endpoint);
}

int TAO_DIOP_Connector::set_validate_endpoint

(

TAO_Endpoint *

ep

)

[protected, virtual]

Implements TAO_Connector.

Definition at line 58 of file DIOP_Connector.cpp.

References ACE_DEBUG, ACE_TEXT, AF_INET, ACE_Addr::get_type(), LM_DEBUG, TAO_DIOP_Endpoint::object_addr(), remote_endpoint(), and TAO_debug_level.

{
  TAO_DIOP_Endpoint *diop_endpoint =
    this->remote_endpoint (endpoint);

  if (diop_endpoint == 0)
    return -1;

  const ACE_INET_Addr &remote_address =
    diop_endpoint->object_addr ();

  // Verify that the remote ACE_INET_Addr was initialized properly.
  // Failure can occur if hostname lookup failed when initializing the
  // remote ACE_INET_Addr.
#if defined (ACE_HAS_IPV6)
   if (remote_address.get_type () != AF_INET &&
       remote_address.get_type () != AF_INET6)
#else /* ACE_HAS_IPV6 */
  if (remote_address.get_type () != AF_INET)
#endif /* !ACE_HAS_IPV6 */
    {
      if (TAO_debug_level > 0)
        {
          ACE_DEBUG ((LM_DEBUG,
                      ACE_TEXT ("TAO (%P|%t) - DIOP connection failed.\n")
                      ACE_TEXT ("TAO (%P|%t) This is most likely ")
                      ACE_TEXT ("due to a hostname lookup ")
                      ACE_TEXT ("failure.\n")));
        }

      return -1;
    }

  return 0;
}

---

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

• DIOP_Connector.h
• DIOP_Connector.cpp

---