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 ACE_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. Referenced by open_i().

typedef ACE_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. Referenced by open_i().

typedef TAO_Creation_Strategy<TAO_UIOP_Connection_Handler> TAO_UIOP_Acceptor::TAO_UIOP_CREATION_STRATEGY

Definition at line 57 of file UIOP_Acceptor.h. Referenced by open_i().

---

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. References TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, and TAO_TAG_UIOP_PROFILE. : TAO_Acceptor (TAO_TAG_UIOP_PROFILE), base_acceptor_ (), 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 close(). { // 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 ACE_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >::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_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), 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, TAO_ORB_Core::orb_params(), TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Codeset_Manager::set_codeset(), TAO_Tagged_Components::set_orb_type(), TAO_MProfile::size(), TAO_ORB_Parameters::std_profile_components(), TAO_Profile::tagged_components(), and TAO_ORB_TYPE. 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_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), 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(), TAO_PHandle, 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 334 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 .

int TAO_UIOP_Acceptor::is_collocated (  const TAO_Endpoint *  endpoint  )  [virtual]

Implements TAO_Acceptor. Definition at line 158 of file UIOP_Acceptor.cpp. References ACE_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), and 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 340 of file UIOP_Acceptor.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, LM_DEBUG, LM_ERROR, IOP::TaggedProfile::profile_data, ACE_InputCDR::read_octet(), ACE_InputCDR::read_string(), 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(), parse_options(), and TAO_GIOP_Message_Version::set_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(), parse_options(), and TAO_GIOP_Message_Version::set_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_Strategy_Acceptor< SVC_HANDLER, >::acceptor(), ACE_CLOEXEC, ACE_DEBUG, ACE_NEW_RETURN, EADDRINUSE, ACE_UNIX_Addr::get_path_name(), LM_DEBUG, ACE_Strategy_Acceptor< SVC_HANDLER, >::open(), rendezvous_point(), TAO_debug_level, TAO_UIOP_ACCEPT_STRATEGY, TAO_UIOP_CONCURRENCY_STRATEGY, TAO_UIOP_CREATION_STRATEGY, 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 ())); return 0; }

int TAO_UIOP_Acceptor::parse_options (  const char *  options  )  [private]

Parse protocol specific options. Definition at line 389 of file UIOP_Acceptor.cpp. References ACE_CString, ACE_ERROR_RETURN, ACE_TEXT, and LM_ERROR. Referenced by open(), and open_default(). { 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 292 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.

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.

TAO_UIOP_CONCURRENCY_STRATEGY* TAO_UIOP_Acceptor::concurrency_strategy_ [private]

Definition at line 122 of file UIOP_Acceptor.h.

TAO_UIOP_CREATION_STRATEGY* TAO_UIOP_Acceptor::creation_strategy_ [private]

Definition at line 121 of file UIOP_Acceptor.h.

TAO_ORB_Core* TAO_UIOP_Acceptor::orb_core_ [private]

ORB Core. Definition at line 129 of file UIOP_Acceptor.h.

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.

---

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

• UIOP_Acceptor.h
• UIOP_Acceptor.cpp

---