TAO_UIOP_Acceptor Class Reference

The UIOP-specific bridge class for the concrete acceptor. More...

#include <UIOP_Acceptor.h>

Inheritance diagram for TAO_UIOP_Acceptor:

[legend]Collaboration diagram for TAO_UIOP_Acceptor:

[legend]List of all members.

Public Types
typedef TAO_Strategy_Acceptor< TAO_UIOP_Connection_Handler, ACE_LSOCK_ACCEPTOR >	TAO_UIOP_BASE_ACCEPTOR
typedef TAO_Creation_Strategy< TAO_UIOP_Connection_Handler >	TAO_UIOP_CREATION_STRATEGY
typedef TAO_Concurrency_Strategy< TAO_UIOP_Connection_Handler >	TAO_UIOP_CONCURRENCY_STRATEGY
typedef TAO_Accept_Strategy< TAO_UIOP_Connection_Handler, ACE_LSOCK_ACCEPTOR >	TAO_UIOP_ACCEPT_STRATEGY
Public Member Functions
	TAO_UIOP_Acceptor (void)
	Create Acceptor object using addr.
virtual	~TAO_UIOP_Acceptor (void)
	Destructor.
The TAO_Acceptor Methods
Please check the documentation in Transport_Acceptor.h for details.
virtual int	open (TAO_ORB_Core *orb_core, ACE_Reactor *reactor, int version_major, int version_minor, const char *address, const char *options=0)
virtual int	open_default (TAO_ORB_Core *orb_core, ACE_Reactor *reactor, int version_major, int version_minor, const char *options=0)
virtual int	close (void)
virtual int	create_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
virtual int	is_collocated (const TAO_Endpoint *endpoint)
virtual CORBA::ULong	endpoint_count (void)
virtual int	object_key (IOP::TaggedProfile &profile, TAO::ObjectKey &key)
Private Member Functions
int	open_i (const char *rendezvous, ACE_Reactor *reactor)
	Implement the common part of the open*() methods.
void	rendezvous_point (ACE_UNIX_Addr &, const char *rendezvous)
int	parse_options (const char *options)
	Parse protocol specific options.
int	init_uiop_properties (void)
int	create_new_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
	Create a UIOP profile representing this acceptor.
int	create_shared_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
	Add the endpoints on this acceptor to a shared profile.
Private Attributes
TAO_UIOP_BASE_ACCEPTOR	base_acceptor_
	The concrete acceptor, as a pointer to its base class.
TAO_UIOP_CREATION_STRATEGY *	creation_strategy_
TAO_UIOP_CONCURRENCY_STRATEGY *	concurrency_strategy_
TAO_UIOP_ACCEPT_STRATEGY *	accept_strategy_
TAO_GIOP_Message_Version	version_
	The GIOP version for this endpoint.
TAO_ORB_Core *	orb_core_
	ORB Core.
bool	unlink_on_close_

---

Detailed Description

The UIOP-specific bridge class for the concrete acceptor.

Definition at line 44 of file UIOP_Acceptor.h.

---

Member Typedef Documentation

typedef TAO_Accept_Strategy<TAO_UIOP_Connection_Handler, ACE_LSOCK_ACCEPTOR> TAO_UIOP_Acceptor::TAO_UIOP_ACCEPT_STRATEGY

Definition at line 59 of file UIOP_Acceptor.h.

typedef TAO_Strategy_Acceptor<TAO_UIOP_Connection_Handler, ACE_LSOCK_ACCEPTOR> TAO_UIOP_Acceptor::TAO_UIOP_BASE_ACCEPTOR

Definition at line 56 of file UIOP_Acceptor.h.

typedef TAO_Concurrency_Strategy<TAO_UIOP_Connection_Handler> TAO_UIOP_Acceptor::TAO_UIOP_CONCURRENCY_STRATEGY

Definition at line 58 of file UIOP_Acceptor.h.

typedef TAO_Creation_Strategy<TAO_UIOP_Connection_Handler> TAO_UIOP_Acceptor::TAO_UIOP_CREATION_STRATEGY

Definition at line 57 of file UIOP_Acceptor.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_UIOP_Acceptor::TAO_UIOP_Acceptor

(

void

)

Create Acceptor object using addr.

Definition at line 24 of file UIOP_Acceptor.cpp.

  : TAO_Acceptor (TAO_TAG_UIOP_PROFILE),
    base_acceptor_ (this),
    creation_strategy_ (0),
    concurrency_strategy_ (0),
    accept_strategy_ (0),
    version_ (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR),
    orb_core_ (0),
    unlink_on_close_ (true)
{
}

TAO_UIOP_Acceptor::~TAO_UIOP_Acceptor

(

void

)

[virtual]

Destructor.

Definition at line 36 of file UIOP_Acceptor.cpp.

References accept_strategy_, close(), concurrency_strategy_, and creation_strategy_.

{
  // Make sure we are closed before we start destroying the
  // strategies.
  this->close ();

  delete this->creation_strategy_;
  delete this->concurrency_strategy_;
  delete this->accept_strategy_;
}

---

Member Function Documentation

int TAO_UIOP_Acceptor::close

(

void

)

[virtual]

Implements TAO_Acceptor.

Definition at line 176 of file UIOP_Acceptor.cpp.

References base_acceptor_, ACE_Acceptor< SVC_HANDLER, >::close(), ACE_UNIX_Addr::get_path_name(), ACE_OS::unlink(), and unlink_on_close_.

Referenced by ~TAO_UIOP_Acceptor().

{
  if (this->unlink_on_close_)
    {
      ACE_UNIX_Addr addr;

      if (this->base_acceptor_.acceptor ().get_local_addr (addr) == 0)
        (void) ACE_OS::unlink (addr.get_path_name ());

      this->unlink_on_close_ = false;
    }

  return this->base_acceptor_.close ();
}

int TAO_UIOP_Acceptor::create_new_profile	(	const TAO::ObjectKey &	object_key,
		TAO_MProfile &	mprofile,
		CORBA::Short	priority
	)			[private]

Create a UIOP profile representing this acceptor.

Definition at line 66 of file UIOP_Acceptor.cpp.

References TAO_Profile::_decr_refcnt(), ACE_NEW_RETURN, TAO_ORB_Core::codeset_manager(), TAO_UIOP_Profile::endpoint(), TAO_MProfile::give_profile(), TAO_MProfile::grow(), TAO_GIOP_Message_Version::major, TAO_GIOP_Message_Version::minor, orb_core_, TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Codeset_Manager::set_codeset(), TAO_Tagged_Components::set_orb_type(), TAO_MProfile::size(), TAO_Profile::tagged_components(), TAO_ORB_TYPE, and version_.

Referenced by create_profile(), and create_shared_profile().

{
  ACE_UNIX_Addr addr;

  if (this->base_acceptor_.acceptor ().get_local_addr (addr) == -1)
    return 0;

  int count = mprofile.profile_count ();
  if ((mprofile.size () - count) < 1
      && mprofile.grow (count + 1) == -1)
    return -1;

  TAO_UIOP_Profile *pfile = 0;
  ACE_NEW_RETURN (pfile,
                  TAO_UIOP_Profile (addr,
                                    object_key,
                                    this->version_,
                                    this->orb_core_),
                  -1);
  pfile->endpoint ()->priority (priority);

  if (mprofile.give_profile (pfile) == -1)
    {
      pfile->_decr_refcnt ();
      pfile = 0;
      return -1;
    }

  // Do not add any tagged components to the profile if configured
  // by the user not to do so, or if an UIOP 1.0 endpoint is being
  // created (IIOP 1.0 did not support tagged components, so we follow
  // the same convention for UIOP).
  if (this->orb_core_->orb_params ()->std_profile_components () == 0
      || (this->version_.major == 1 && this->version_.minor == 0))
    return 0;

  pfile->tagged_components ().set_orb_type (TAO_ORB_TYPE);
  TAO_Codeset_Manager *csm = this->orb_core_->codeset_manager();
  if (csm)
    csm->set_codeset(pfile->tagged_components());
  return 0;
}

int TAO_UIOP_Acceptor::create_profile	(	const TAO::ObjectKey &	object_key,
		TAO_MProfile &	mprofile,
		CORBA::Short	priority
	)			[virtual]

Implements TAO_Acceptor.

Definition at line 48 of file UIOP_Acceptor.cpp.

References create_new_profile(), create_shared_profile(), and TAO_INVALID_PRIORITY.

{
  // Check if multiple endpoints should be put in one profile or
  // if they should be spread across multiple profiles.
  if (priority == TAO_INVALID_PRIORITY)
    return this->create_new_profile (object_key,
                                     mprofile,
                                     priority);
  else
    return this->create_shared_profile (object_key,
                                        mprofile,
                                        priority);

}

int TAO_UIOP_Acceptor::create_shared_profile	(	const TAO::ObjectKey &	object_key,
		TAO_MProfile &	mprofile,
		CORBA::Short	priority
	)			[private]

Add the endpoints on this acceptor to a shared profile.

Definition at line 112 of file UIOP_Acceptor.cpp.

References ACE_NEW_RETURN, TAO_UIOP_Profile::add_endpoint(), create_new_profile(), TAO_MProfile::get_profile(), TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Profile::tag(), and TAO_TAG_UIOP_PROFILE.

Referenced by create_profile().

{
  TAO_Profile *pfile = 0;
  TAO_UIOP_Profile *uiop_profile = 0;

  // First see if <mprofile> already contains a UIOP profile.
  for (TAO_PHandle i = 0; i != mprofile.profile_count (); ++i)
    {
      pfile = mprofile.get_profile (i);
      if (pfile->tag () == TAO_TAG_UIOP_PROFILE)
      {
        uiop_profile = dynamic_cast<TAO_UIOP_Profile *> (pfile);
        break;
      }
    }

  if (uiop_profile == 0)
    {
      // If <mprofile> doesn't contain UIOP_Profile, we need to create
      // one.
      return create_new_profile (object_key,
                                 mprofile,
                                 priority);
    }
  else
    {
      // A UIOP_Profile already exists - just add our endpoint to it.
      ACE_UNIX_Addr addr;

      if (this->base_acceptor_.acceptor ().get_local_addr (addr) == -1)
        return 0;

      TAO_UIOP_Endpoint *endpoint = 0;
      ACE_NEW_RETURN (endpoint,
                      TAO_UIOP_Endpoint (addr),
                      -1);
      endpoint->priority (priority);
      uiop_profile->add_endpoint (endpoint);

      return 0;
    }
}

CORBA::ULong TAO_UIOP_Acceptor::endpoint_count

(

void

)

[virtual]

Implements TAO_Acceptor.

Definition at line 342 of file UIOP_Acceptor.cpp.

{
  return 1;
}

int TAO_UIOP_Acceptor::init_uiop_properties

(

void

)

[private]

Obtains uiop properties that must be used by this acceptor, i.e., initializes <uiop_properties_>.

int TAO_UIOP_Acceptor::is_collocated

(

const TAO_Endpoint *

endpoint

)

[virtual]

Implements TAO_Acceptor.

Definition at line 158 of file UIOP_Acceptor.cpp.

References TAO_UIOP_Endpoint::object_addr().

{
  const TAO_UIOP_Endpoint *endp =
    dynamic_cast<const TAO_UIOP_Endpoint *> (endpoint);

  // Make sure the dynamically cast pointer is valid.
  if (endp == 0)
    return 0;

  // For UNIX Files this is relatively cheap.
  ACE_UNIX_Addr address;
  if (this->base_acceptor_.acceptor ().get_local_addr (address) == -1)
    return 0;

  return endp->object_addr () == address;
}

int TAO_UIOP_Acceptor::object_key	(	IOP::TaggedProfile &	profile,
		TAO::ObjectKey &	key
	)			[virtual]

Implements TAO_Acceptor.

Definition at line 348 of file UIOP_Acceptor.cpp.

References ACE_DEBUG, ACE_ERROR, ACE_TEXT, LM_DEBUG, LM_ERROR, and TAO_debug_level.

{
  // Create the decoding stream from the encapsulation in the buffer,
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
  TAO_InputCDR cdr (profile.profile_data.mb ());
#else
  TAO_InputCDR cdr (reinterpret_cast<char*> (profile.profile_data.get_buffer ()),
                    profile.profile_data.length ());
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */

  CORBA::Octet major, minor;

  // Read the version. We just read it here. We don't *do any*
  // processing.
  if (!(cdr.read_octet (major) && cdr.read_octet (minor)))
    {
      if (TAO_debug_level > 0)
        {
          ACE_DEBUG ((LM_DEBUG,
                      ACE_TEXT ("TAO (%P|%t) IIOP_Profile::decode - v%d.%d\n"),
                      major,
                      minor));
        }

      return -1;
    }

  char * rendezvous = 0;

  // Get rendezvous_point
  if (cdr.read_string (rendezvous) == 0)
    {
      ACE_ERROR ((LM_ERROR, "error decoding UIOP rendezvous_point"));

      return -1;
    }

  // delete the rendezvous point. We don't do any processing.
  delete [] rendezvous;

  // ... and object key.
  if ((cdr >> object_key) == 0)
    return -1;

  return 1;
}

int TAO_UIOP_Acceptor::open	(	TAO_ORB_Core *	orb_core,
		ACE_Reactor *	reactor,
		int	version_major,
		int	version_minor,
		const char *	address,
		const char *	options = 0
	)			[virtual]

Implements TAO_Acceptor.

Definition at line 192 of file UIOP_Acceptor.cpp.

References open_i(), orb_core_, TAO_GIOP_Message_Version::set_version(), and version_.

{
  this->orb_core_ = orb_core;

  if (address == 0)
    return -1;

  if (major >= 0 && minor >= 0)
    this->version_.set_version (static_cast<CORBA::Octet> (major),
                                static_cast<CORBA::Octet> (minor));
  // Parse options
  if (this->parse_options (options) == -1)
    return -1;
  else
    return this->open_i (address,
                         reactor);
}

int TAO_UIOP_Acceptor::open_default	(	TAO_ORB_Core *	orb_core,
		ACE_Reactor *	reactor,
		int	version_major,
		int	version_minor,
		const char *	options = 0
	)			[virtual]

Implements TAO_Acceptor.

Definition at line 216 of file UIOP_Acceptor.cpp.

References ACE_Auto_String_Free::get(), open_i(), orb_core_, TAO_GIOP_Message_Version::set_version(), ACE_OS::tempnam(), and version_.

{
  this->orb_core_ = orb_core;

  if (major >= 0 && minor >= 0)
    this->version_.set_version (static_cast<CORBA::Octet> (major),
                                static_cast<CORBA::Octet> (minor));

  // Parse options
  if (this->parse_options (options) == -1)
    return -1;

  ACE_Auto_String_Free tempname (ACE_OS::tempnam (0, "TAO"));

  if (tempname.get () == 0)
    return -1;

  return this->open_i (tempname.get (),
                       reactor);
}

int TAO_UIOP_Acceptor::open_i	(	const char *	rendezvous,
		ACE_Reactor *	reactor
	)			[private]

Implement the common part of the open*() methods.

Definition at line 242 of file UIOP_Acceptor.cpp.

References ACE_CLOEXEC, ACE_DEBUG, ACE_NEW_RETURN, ACE_UNIX_Addr::get_path_name(), LM_DEBUG, rendezvous_point(), TAO_Acceptor::set_error_retry_delay(), TAO_debug_level, and unlink_on_close_.

Referenced by open(), and open_default().

{
  ACE_NEW_RETURN (this->creation_strategy_,
                  TAO_UIOP_CREATION_STRATEGY (this->orb_core_),
                  -1);

  ACE_NEW_RETURN (this->concurrency_strategy_,
                  TAO_UIOP_CONCURRENCY_STRATEGY (this->orb_core_),
                  -1);

  ACE_NEW_RETURN (this->accept_strategy_,
                  TAO_UIOP_ACCEPT_STRATEGY (this->orb_core_),
                  -1);

  ACE_UNIX_Addr addr;

  this->rendezvous_point (addr, rendezvous);

  if (this->base_acceptor_.open (addr,
                                 reactor,
                                 this->creation_strategy_,
                                 this->accept_strategy_,
                                 this->concurrency_strategy_) == -1)
    {
      // Don't unlink an existing rendezvous point since it may be in
      // use by another UIOP server/client.
      if (errno == EADDRINUSE)
        this->unlink_on_close_ = false;

      return -1;
    }

  (void) this->base_acceptor_.acceptor().enable (ACE_CLOEXEC);
  // This avoids having child processes acquire the listen socket thereby
  // denying the server the opportunity to restart on a well-known endpoint.
  // This does not affect the aberrent behavior on Win32 platforms.

  // @@ If Profile creation is slow we may need to cache the
  //    rendezvous point here

  if (TAO_debug_level > 5)
    ACE_DEBUG ((LM_DEBUG,
                "\nTAO (%P|%t) UIOP_Acceptor::open_i - "
                "listening on: <%s>\n",
                addr.get_path_name ()));

  // In the event that an accept() fails, we can examine the reason.  If
  // the reason warrants it, we can try accepting again at a later time.
  // The amount of time we wait to accept again is governed by this orb
  // parameter.
  this->set_error_retry_delay (
    this->orb_core_->orb_params ()->accept_error_delay());

  return 0;
}

int TAO_UIOP_Acceptor::parse_options

(

const char *

options

)

[private]

Parse protocol specific options.

Definition at line 397 of file UIOP_Acceptor.cpp.

References ACE_ERROR_RETURN, ACE_TEXT, ACE_String_Base< CHAR >::c_str(), ACE_String_Base< CHAR >::find(), ACE_String_Base< CHAR >::length(), LM_ERROR, ACE_String_Base_Const::npos, and ACE_String_Base< CHAR >::substring().

{
  if (str == 0)
    return 0;  // No options to parse.  Not a problem.

  // Use an option format similar to the one used for CGI scripts in
  // HTTP URLs.
  // e.g.:  option1=foo&option2=bar

  ACE_CString options (str);

  const size_t len = options.length ();

  static const char option_delimiter = '&';

  // Count the number of options.

  CORBA::ULong option_count = 1;
  // Number of endpoints in the string (initialized to 1).

  // Only check for endpoints after the protocol specification and
  // before the object key.
  for (size_t i = 0; i < len; ++i)
    if (options[i] == option_delimiter)
      ++option_count;

  // The idea behind the following loop is to split the options into
  // (option, name) pairs.
  // For example,
  //    `option1=foo&option2=bar'
  // will be parsed into:
  //    `option1=foo'
  //    `option2=bar'

  ACE_CString::size_type begin = 0;
  ACE_CString::size_type end = 0;

  for (CORBA::ULong j = 0; j < option_count; ++j)
    {
      if (j < option_count - 1)
        end = options.find (option_delimiter, begin);
      else
        end = len;

      if (end == begin)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "TAO (%P|%t) Zero length UIOP option.\n"),
                          -1);
      else if (end != ACE_CString::npos)
        {
          ACE_CString opt =
            options.substring (begin, end - begin);

          ACE_CString::size_type const slot = opt.find ("=");

          if (slot == len - 1
              || slot == ACE_CString::npos)
            ACE_ERROR_RETURN ((LM_ERROR,
                               "TAO (%P|%t) UIOP option <%s> is "
                               "missing a value.\n",
                               opt.c_str ()),
                              -1);

          const ACE_CString name (opt.substring (0, slot));
          ACE_CString value = opt.substring (slot + 1);

          begin = end + 1;

          if (name.length () == 0)
            ACE_ERROR_RETURN ((LM_ERROR,
                               "TAO (%P|%t) Zero length UIOP "
                               "option name.\n"),
                              -1);

          if (name == "priority")
            {
              ACE_ERROR_RETURN ((LM_ERROR,
                                 ACE_TEXT ("TAO (%P|%t) Invalid UIOP endpoint format: ")
                                 ACE_TEXT ("endpoint priorities no longer supported. \n")),
                                -1);
            }
          else
            ACE_ERROR_RETURN ((LM_ERROR,
                               "TAO (%P|%t) Invalid UIOP option: <%s>\n",
                               name.c_str ()),
                              -1);
        }
      else
        break;  // No other options.
    }
  return 0;
}

void TAO_UIOP_Acceptor::rendezvous_point	(	ACE_UNIX_Addr &	,
		const char *	rendezvous
	)			[private]

Set the rendezvous point and verify that it is valid (e.g. wasn't truncated because it was too long).

Definition at line 300 of file UIOP_Acceptor.cpp.

References ACE_DEBUG, ACE_UNIX_Addr::get_path_name(), LM_WARNING, ACE_UNIX_Addr::set(), and ACE_OS::strlen().

Referenced by open_i().

{
  // To guarantee portability, local IPC rendezvous points (including
  // the path and filename) should not be longer than 99 characters
  // long. Some platforms may support longer rendezvous points,
  // usually 108 characters including the null terminator, but
  // Posix.1g only requires that local IPC rendezvous point arrays
  // contain a maximum of at least 100 characters, including the null
  // terminator.  If an endpoint is longer than what the platform
  // supports then it will be truncated so that it fits, and a warning
  // will be issued.

  // Avoid using relative paths in your UIOP endpoints.  If possible,
  // use absolute paths instead.  Imagine that the server is given an
  // endpoint to create using -ORBEndpoint uiop://foobar.  A local IPC
  // rendezvous point called foobar will be created in the current
  // working directory.  If the client is not started in the directory
  // where the foobar rendezvous point exists then the client will not
  // be able to communicate with the server since its point of
  // communication, the rendezvous point, was not found. On the other
  // hand, if an absolute path was used, the client would know exactly
  // where to find the rendezvous point.  It is up to the user to make
  // sure that a given UIOP endpoint is accessible by both the server
  // and the client.

  addr.set (rendezvous);

  const size_t length = ACE_OS::strlen (addr.get_path_name ());

  // Check if rendezvous point was truncated by ACE_UNIX_Addr since
  // most UNIX domain socket rendezvous points can only be less than
  // 108 characters long.
  if (length < ACE_OS::strlen (rendezvous))
    ACE_DEBUG ((LM_WARNING,
                "TAO (%P|%t) UIOP rendezvous point was truncated to <%s>\n"
                "since it was longer than %d characters long.\n",
                addr.get_path_name (),
                length));
}

---

Member Data Documentation

TAO_UIOP_ACCEPT_STRATEGY* TAO_UIOP_Acceptor::accept_strategy_ [private]

Definition at line 123 of file UIOP_Acceptor.h.

Referenced by ~TAO_UIOP_Acceptor().

TAO_UIOP_BASE_ACCEPTOR TAO_UIOP_Acceptor::base_acceptor_ [private]

The concrete acceptor, as a pointer to its base class.

Definition at line 118 of file UIOP_Acceptor.h.

Referenced by close().

TAO_UIOP_CONCURRENCY_STRATEGY* TAO_UIOP_Acceptor::concurrency_strategy_ [private]

Definition at line 122 of file UIOP_Acceptor.h.

Referenced by ~TAO_UIOP_Acceptor().

TAO_UIOP_CREATION_STRATEGY* TAO_UIOP_Acceptor::creation_strategy_ [private]

Definition at line 121 of file UIOP_Acceptor.h.

Referenced by ~TAO_UIOP_Acceptor().

TAO_ORB_Core* TAO_UIOP_Acceptor::orb_core_ [private]

ORB Core.

Definition at line 129 of file UIOP_Acceptor.h.

Referenced by create_new_profile(), open(), and open_default().

bool TAO_UIOP_Acceptor::unlink_on_close_ [private]

Flag that determines whether or not the rendezvous point should be unlinked on close. This is really only used when an error occurs.

Definition at line 134 of file UIOP_Acceptor.h.

Referenced by close(), and open_i().

TAO_GIOP_Message_Version TAO_UIOP_Acceptor::version_ [private]

The GIOP version for this endpoint.

Definition at line 126 of file UIOP_Acceptor.h.

Referenced by create_new_profile(), open(), and open_default().

---

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

• UIOP_Acceptor.h
• UIOP_Acceptor.cpp

---