TAO_DIOP_Acceptor Class Reference

TAO_DIOP_Acceptor. More...

#include <DIOP_Acceptor.h>

Inheritance diagram for TAO_DIOP_Acceptor:

[legend]Collaboration diagram for TAO_DIOP_Acceptor:

[legend]List of all members.

Public Member Functions
	TAO_DIOP_Acceptor (CORBA::Boolean flag=false)
	Constructor.
	~TAO_DIOP_Acceptor (void)
	Destructor.
const ACE_INET_Addr &	address (void) const
const ACE_INET_Addr *	endpoints (void)
	Returns the array of endpoints in this acceptor.
int	hostname (TAO_ORB_Core *orb_core, ACE_INET_Addr &addr, char *&host, const char *specified_hostname=0)
int	dotted_decimal_address (ACE_INET_Addr &addr, char *&host)
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)
Protected Member Functions
virtual int	open_i (const ACE_INET_Addr &addr, ACE_Reactor *reactor)
int	probe_interfaces (TAO_ORB_Core *orb_core)
virtual int	parse_options (const char *options)
	Parse protocol specific options.
int	create_new_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
int	create_shared_profile (const TAO::ObjectKey &object_key, TAO_MProfile &mprofile, CORBA::Short priority)
Protected Attributes
ACE_INET_Addr *	addrs_
char **	hosts_
CORBA::ULong	endpoint_count_
TAO_GIOP_Message_Version	version_
TAO_ORB_Core *	orb_core_
	ORB Core.
CORBA::Boolean	lite_flag_
	Should we use GIOP lite??
Private Attributes
TAO_DIOP_Connection_Handler *	connection_handler_

---

Detailed Description

TAO_DIOP_Acceptor.

The DIOP-specific bridge class for the concrete acceptor.

Definition at line 46 of file DIOP_Acceptor.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_DIOP_Acceptor::TAO_DIOP_Acceptor (  CORBA::Boolean  flag = false  )

Constructor. Definition at line 31 of file DIOP_Acceptor.cpp. References TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, and TAO_TAG_DIOP_PROFILE. : TAO_Acceptor (TAO_TAG_DIOP_PROFILE), addrs_ (0), hosts_ (0), endpoint_count_ (0), version_ (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR), orb_core_ (0), lite_flag_ (flag), connection_handler_ (0) { }

TAO_DIOP_Acceptor::~TAO_DIOP_Acceptor (  void   )

Destructor. Definition at line 43 of file DIOP_Acceptor.cpp. References close(), and CORBA::string_free(). { // Make sure we are closed before we start destroying the // strategies. this->close (); delete [] this->addrs_; for (size_t i = 0; i < this->endpoint_count_; ++i) CORBA::string_free (this->hosts_[i]); delete [] this->hosts_; }

---

Member Function Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE const ACE_INET_Addr & TAO_DIOP_Acceptor::address (  void   )  const

@ Helper method for the implementation repository, should go away Definition at line 8 of file DIOP_Acceptor.i. References ACE_ASSERT. { ACE_ASSERT (this->addrs_ != 0); // @@ This is busted. // The Implementation Repository will have to start supporting // IORs with multiple profiles. For now, we just return the // first addr. // -Ossama return this->addrs_[0]; }

int TAO_DIOP_Acceptor::close (  void   )  [virtual]

Implements TAO_Acceptor. Definition at line 228 of file DIOP_Acceptor.cpp. Referenced by ~TAO_DIOP_Acceptor(). { return 0; }

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

Helper method to add a new profile to the mprofile for each endpoint. Definition at line 82 of file DIOP_Acceptor.cpp. References TAO_Profile::_decr_refcnt(), ACE_NEW_RETURN, TAO_ORB_Core::codeset_manager(), TAO_DIOP_Profile::endpoint(), TAO_MProfile::give_profile(), TAO_MProfile::grow(), 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(). { // Adding this->endpoint_count_ to the TAO_MProfile. int const count = mprofile.profile_count (); if ((mprofile.size () - count) < this->endpoint_count_ && mprofile.grow (count + this->endpoint_count_) == -1) return -1; // Create a profile for each acceptor endpoint. for (size_t i = 0; i < this->endpoint_count_; ++i) { TAO_DIOP_Profile *pfile = 0; ACE_NEW_RETURN (pfile, TAO_DIOP_Profile (this->hosts_[i], this->addrs_[i].get_port_number (), object_key, this->addrs_[i], 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 IIOP 1.0 endpoint is being // created (IIOP 1.0 did not support tagged components). if (this->orb_core_->orb_params ()->std_profile_components () == 0 || (this->version_.major == 1 && this->version_.minor == 0)) continue; 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_DIOP_Acceptor::create_profile (  const TAO::ObjectKey &  object_key, TAO_MProfile &  mprofile, CORBA::Short  priority )  [virtual]

Implements TAO_Acceptor. Definition at line 61 of file DIOP_Acceptor.cpp. References create_new_profile(), create_shared_profile(), and TAO_INVALID_PRIORITY. { // Sanity check. if (this->endpoint_count_ == 0) return -1; // 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_DIOP_Acceptor::create_shared_profile (  const TAO::ObjectKey &  object_key, TAO_MProfile &  mprofile, CORBA::Short  priority )  [protected]

Helper method to create a profile that contains all of our endpoints. Definition at line 131 of file DIOP_Acceptor.cpp. References TAO_Profile::_decr_refcnt(), ACE_NEW_RETURN, TAO_DIOP_Profile::add_endpoint(), TAO_ORB_Core::codeset_manager(), TAO_DIOP_Profile::endpoint(), TAO_MProfile::get_profile(), TAO_MProfile::give_profile(), TAO_ORB_Core::orb_params(), TAO_Endpoint::priority(), TAO_MProfile::profile_count(), TAO_Codeset_Manager::set_codeset(), TAO_Tagged_Components::set_orb_type(), TAO_ORB_Parameters::std_profile_components(), TAO_Profile::tag(), TAO_Profile::tagged_components(), TAO_ORB_TYPE, TAO_PHandle, and TAO_TAG_DIOP_PROFILE. Referenced by create_profile(). { size_t index = 0; TAO_Profile *pfile = 0; TAO_DIOP_Profile *iiop_profile = 0; // First see if <mprofile> already contains a DIOP profile. for (TAO_PHandle i = 0; i != mprofile.profile_count (); ++i) { pfile = mprofile.get_profile (i); if (pfile->tag () == TAO_TAG_DIOP_PROFILE) { iiop_profile = dynamic_cast<TAO_DIOP_Profile *> (pfile); break; } } // If <mprofile> doesn't contain a DIOP_Profile, we need to create // one. if (iiop_profile == 0) { ACE_NEW_RETURN (iiop_profile, TAO_DIOP_Profile (this->hosts_[0], this->addrs_[0].get_port_number (), object_key, this->addrs_[0], this->version_, this->orb_core_), -1); iiop_profile->endpoint ()->priority (priority); if (mprofile.give_profile (iiop_profile) == -1) { iiop_profile->_decr_refcnt (); iiop_profile = 0; return -1; } if (this->orb_core_->orb_params ()->std_profile_components () != 0 && (this->version_.major >= 1 && this->version_.minor >= 1)) { iiop_profile->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()); } index = 1; } // Add any remaining acceptor endpoints to the DIOP_Profile. for (; index < this->endpoint_count_; ++index) { TAO_DIOP_Endpoint *endpoint = 0; ACE_NEW_RETURN (endpoint, TAO_DIOP_Endpoint (this->hosts_[index], this->addrs_[index].get_port_number (), this->addrs_[index]), -1); endpoint->priority (priority); iiop_profile->add_endpoint (endpoint); } return 0; }

int TAO_DIOP_Acceptor::dotted_decimal_address (  ACE_INET_Addr &  addr, char *&  host )

Set the host name for the given address using the dotted decimal format. Definition at line 487 of file DIOP_Acceptor.cpp. References ACE_DEBUG, ACE_TEXT, ACE_INET_Addr::get_host_addr(), LM_DEBUG, CORBA::string_dup(), and TAO_debug_level. Referenced by hostname(). { const char *tmp = addr.get_host_addr (); if (tmp == 0) { if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\n\nTAO (%P|%t) ") ACE_TEXT ("DIOP_Acceptor::dotted_decimal_address ") ACE_TEXT ("- %p\n\n"), ACE_TEXT ("cannot determine hostname"))); return -1; } host = CORBA::string_dup (tmp); return 0; }

CORBA::ULong TAO_DIOP_Acceptor::endpoint_count (  void   )  [virtual]

Implements TAO_Acceptor. Definition at line 601 of file DIOP_Acceptor.cpp. { return this->endpoint_count_; }

ACE_INLINE const ACE_INET_Addr * TAO_DIOP_Acceptor::endpoints (  void   )

Returns the array of endpoints in this acceptor. Definition at line 21 of file DIOP_Acceptor.i. References ACE_ASSERT. { ACE_ASSERT (this->addrs_ != 0); return this->addrs_; }

int TAO_DIOP_Acceptor::hostname (  TAO_ORB_Core *  orb_core, ACE_INET_Addr &  addr, char *&  host, const char *  specified_hostname = 0 )

Set the host name for the given addr. A hostname may be forced by using specified_hostname. This is useful if the given address corresponds to more than one hostname and the desired one cannot be determined in any other way. Definition at line 449 of file DIOP_Acceptor.cpp. References dotted_decimal_address(), ACE_INET_Addr::get_host_name(), MAXHOSTNAMELEN, TAO_ORB_Core::orb_params(), CORBA::string_dup(), and TAO_ORB_Parameters::use_dotted_decimal_addresses(). Referenced by open(), and probe_interfaces(). { if (orb_core->orb_params ()->use_dotted_decimal_addresses ()) { // If dotted decimal addresses are enabled, // just return ours. return this->dotted_decimal_address (addr, host); } else if (specified_hostname != 0) { // If the user specified a hostname, pass it back // blindly as it overrides our choice of hostname. host = CORBA::string_dup (specified_hostname); } else { char tmp_host[MAXHOSTNAMELEN + 1]; // Get the hostname associated with our address if (addr.get_host_name (tmp_host, sizeof (tmp_host)) != 0) { // On failure, just return the decimal address. return this->dotted_decimal_address (addr, host); } else { host = CORBA::string_dup (tmp_host); } } return 0; }

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

Implements TAO_Acceptor. Definition at line 202 of file DIOP_Acceptor.cpp. References ACE_INET_Addr::get_port_number(), TAO_DIOP_Endpoint::host(), TAO_DIOP_Endpoint::port(), and ACE_OS::strcmp(). { const TAO_DIOP_Endpoint *endp = dynamic_cast<const TAO_DIOP_Endpoint *> (endpoint); // Make sure the dynamically cast pointer is valid. if (endp == 0) return 0; for (size_t i = 0; i < this->endpoint_count_; ++i) { // compare the port and host name. Please do *NOT* optimize // this code by comparing the IP address instead. That would // trigger the following bug: // // http://deuce.doc.wustl.edu/bugzilla/show_bug.cgi?id=1220 // if (endp->port() == this->addrs_[i].get_port_number() && ACE_OS::strcmp(endp->host(), this->hosts_[i]) == 0) return 1; // Collocated } return 0; // Not collocated }

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

Implements TAO_Acceptor. Definition at line 607 of file DIOP_Acceptor.cpp. References ACE_DEBUG, ACE_TEXT, TAO::unbounded_value_sequence< T >::get_buffer(), TAO::unbounded_value_sequence< T >::length(), LM_DEBUG, CORBA::Octet, IOP::TaggedProfile::profile_data, ACE_InputCDR::read_octet(), ACE_InputCDR::read_string(), ACE_InputCDR::read_ushort(), 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; CORBA::Octet minor = CORBA::Octet(); // 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) DIOP_Profile::decode - v%d.%d\n"), major, minor)); } return -1; } CORBA::String_var host; CORBA::UShort port = 0; // Get host and port. No processing here too.. if (cdr.read_string (host.out ()) == 0 || cdr.read_ushort (port) == 0) { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) TAO_DIOP_Acceptor::object_key - ") ACE_TEXT ("error while decoding host/port"))); } return -1; } // ... and object key. if ((cdr >> object_key) == 0) return -1; // We are NOT bothered about the rest. return 1; }

int TAO_DIOP_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 234 of file DIOP_Acceptor.cpp. References ACE_ERROR_RETURN, ACE_NEW_RETURN, ACE_TEXT, ACE_INET_Addr::get_port_number(), hostname(), LM_ERROR, MAXHOSTNAMELEN, ACE_OS::memcpy(), open_i(), parse_options(), probe_interfaces(), ACE_INET_Addr::set(), TAO_GIOP_Message_Version::set_version(), and ACE_OS::strchr(). { this->orb_core_ = orb_core; if (this->hosts_ != 0) { // The hostname cache has already been set! // This is bad mojo, i.e. an internal TAO error. ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) ") ACE_TEXT ("DIOP_Acceptor::open - ") ACE_TEXT ("hostname already set\n\n")), -1); } 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; ACE_INET_Addr addr; const char *port_separator_loc = ACE_OS::strchr (address, ':'); const char *specified_hostname = 0; char tmp_host[MAXHOSTNAMELEN + 1]; if (port_separator_loc == address) { // The address is a port number or port name. No hostname was // specified. The hostname for each network interface and the // fully qualified domain name must be obtained. // Check for multiple network interfaces. if (this->probe_interfaces (orb_core) == -1) return -1; // First convert the port into a usable form. if (addr.set (address + sizeof (':')) != 0) return -1; // Now reset the port and set the host. if (addr.set (addr.get_port_number (), static_cast<ACE_UINT32> (INADDR_ANY), 1) != 0) return -1; else return this->open_i (addr, reactor); } else if (port_separator_loc == 0) { // The address is a hostname. No port was specified, so assume // port zero (port will be chosen for us). if (addr.set ((unsigned short) 0, address) != 0) return -1; specified_hostname = address; } else { // Host and port were specified. if (addr.set (address) != 0) return -1; // Extract out just the host part of the address. size_t len = port_separator_loc - address; ACE_OS::memcpy (tmp_host, address, len); tmp_host[len] = '\0'; specified_hostname = tmp_host; } this->endpoint_count_ = 1; // Only one hostname to store ACE_NEW_RETURN (this->addrs_, ACE_INET_Addr[this->endpoint_count_], -1); ACE_NEW_RETURN (this->hosts_, char *[this->endpoint_count_], -1); this->hosts_[0] = 0; if (this->hostname (orb_core, addr, this->hosts_[0], specified_hostname) != 0) return -1; // Copy the addr. The port is (re)set in // TAO_DIOP_Acceptor::open_i(). if (this->addrs_[0].set (addr) != 0) return -1; return this->open_i (addr, reactor); }

int TAO_DIOP_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 344 of file DIOP_Acceptor.cpp. References ACE_ERROR_RETURN, ACE_TEXT, LM_ERROR, open_i(), parse_options(), probe_interfaces(), ACE_INET_Addr::set(), and TAO_GIOP_Message_Version::set_version(). { this->orb_core_ = orb_core; if (this->hosts_ != 0) { // The hostname cache has already been set! // This is bad mojo, i.e. an internal TAO error. ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) ") ACE_TEXT ("DIOP_Acceptor::open_default - ") ACE_TEXT ("hostname already set\n\n")), -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; // Check for multiple network interfaces. if (this->probe_interfaces (orb_core) == -1) return -1; // Now that each network interface's hostname has been cached, open // an endpoint on each network interface using the INADDR_ANY // address. ACE_INET_Addr addr; if (addr.set (static_cast<unsigned short> (0), static_cast<ACE_UINT32> (INADDR_ANY), 1) != 0) return -1; return this->open_i (addr, reactor); }

int TAO_DIOP_Acceptor::open_i (  const ACE_INET_Addr &  addr, ACE_Reactor *  reactor )  [protected, virtual]

Implement the common part of the open*() methods. This method is virtual to allow a derived class implementation to be invoked instead. Definition at line 390 of file DIOP_Acceptor.cpp. References ACE_DEBUG, ACE_ERROR, ACE_NEW_RETURN, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, TAO_DIOP_Connection_Handler::dgram(), ACE_SOCK::get_local_addr(), ACE_INET_Addr::get_port_number(), LM_DEBUG, LM_ERROR, TAO_DIOP_Connection_Handler::local_addr(), TAO_DIOP_Connection_Handler::open_server(), ACE_Reactor::register_handler(), ACE_Event_Handler::remove_reference(), ACE_INET_Addr::set_port_number(), and TAO_debug_level. Referenced by open(), and open_default(). { ACE_NEW_RETURN (this->connection_handler_, TAO_DIOP_Connection_Handler (this->orb_core_, this->lite_flag_), -1); this->connection_handler_->local_addr (addr); this->connection_handler_->open_server (); // Register only with a valid handle int const result = reactor->register_handler (this->connection_handler_, ACE_Event_Handler::READ_MASK); if (result == -1) return result; // Connection handler ownership now belongs to the Reactor. this->connection_handler_->remove_reference (); ACE_INET_Addr address; // We do this make sure the port number the endpoint is listening on // gets set in the addr. if (this->connection_handler_->dgram ().get_local_addr (address) != 0) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) DIOP_Acceptor::open_i ") ACE_TEXT ("- %p"), ACE_TEXT ("cannot get local addr\n"))); return -1; } // Set the port for each addr. If there is more than one network // interface then the endpoint created on each interface will be on // the same port. This is how a wildcard socket bind() is supposed // to work. u_short const port = address.get_port_number (); for (size_t j = 0; j < this->endpoint_count_; ++j) this->addrs_[j].set_port_number (port, 1); if (TAO_debug_level > 5) { for (size_t i = 0; i < this->endpoint_count_; ++i) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("\nTAO (%P|%t) DIOP_Acceptor::open_i - ") ACE_TEXT ("listening on: <%s:%u>\n"), ACE_TEXT_CHAR_TO_TCHAR (this->hosts_[i]), this->addrs_[i].get_port_number ())); } } return 0; }

int TAO_DIOP_Acceptor::parse_options (  const char *  options  )  [protected, virtual]

Parse protocol specific options. Definition at line 663 of file DIOP_Acceptor.cpp. References ACE_CString, ACE_ERROR_RETURN, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, LM_ERROR, and ssize_t. 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); size_t len = options.length (); 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' ssize_t begin = 0; ssize_t end = -1; for (CORBA::ULong j = 0; j < option_count; ++j) { begin += end + 1; if (j < option_count - 1) end = options.find (option_delimiter, begin); else end = (len - begin); // Handle last endpoint differently if (end == begin) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Zero length DIOP option.\n")), -1); else if (end != ACE_CString::npos) { ACE_CString opt = options.substring (begin, end); ssize_t slot = opt.find ("="); if (slot == static_cast<ssize_t> (len - 1) || slot == ACE_CString::npos) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) DIOP option <%s> is ") ACE_TEXT ("missing a value.\n"), ACE_TEXT_CHAR_TO_TCHAR (opt.c_str ())), -1); ACE_CString name = opt.substring (0, slot); ACE_CString value = opt.substring (slot + 1); if (name.length () == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Zero length DIOP ") ACE_TEXT ("option name.\n")), -1); if (name == "priority") { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Invalid DIOP endpoint format: ") ACE_TEXT ("endpoint priorities no longer supported. \n")), -1); } else ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) Invalid DIOP option: <%s>\n"), ACE_TEXT_CHAR_TO_TCHAR (name.c_str ())), -1); } } return 0; }

int TAO_DIOP_Acceptor::probe_interfaces (  TAO_ORB_Core *  orb_core  )  [protected]

Probe the system for available network interfaces, and initialize the array with an ACE_INET_Addr for each network interface. The port for each initialized ACE_INET_Addr will be set in the open_i() method. This method only gets invoked when no explicit hostname is provided in the specified endpoint. Definition at line 507 of file DIOP_Acceptor.cpp. References ACE_DEBUG, ACE_NEW_RETURN, ACE_TEXT, ENOTSUP, ACE_INET_Addr::get_ip_address(), ACE::get_ip_interfaces(), hostname(), INADDR_LOOPBACK, LM_WARNING, ACE_OS::memset(), ACE_INET_Addr::set(), and TAO_debug_level. Referenced by open(), and open_default(). { // Extract the hostname for each network interface, and then cache // it. The hostnames will then be used when creating a // TAO_DIOP_Profile for each endpoint setup on the probed // network interfaces. ACE_INET_Addr *if_addrs = 0; size_t if_cnt = 0; if (ACE::get_ip_interfaces (if_cnt, if_addrs) != 0 && errno != ENOTSUP) { // In the case where errno == ENOTSUP, if_cnt and if_addrs will // not be modified, and will each remain equal to zero. This // causes the default interface to be used. return -1; } if (if_cnt == 0 || if_addrs == 0) { if (TAO_debug_level > 0) { ACE_DEBUG ((LM_WARNING, ACE_TEXT ("TAO (%P|%t) Unable to probe network ") ACE_TEXT ("interfaces. Using default."))); } if_cnt = 1; // Force the network interface count to be one. delete [] if_addrs; ACE_NEW_RETURN (if_addrs, ACE_INET_Addr[if_cnt], -1); } // Scan for the loopback interface since it shouldn't be included in // the list of cached hostnames unless it is the only interface. size_t lo_cnt = 0; // Loopback interface count for (size_t j = 0; j < if_cnt; ++j) if (if_addrs[j].get_ip_address () == INADDR_LOOPBACK) lo_cnt++; // The instantiation for this template is in // tao/DIOP_Connector.cpp. ACE_Auto_Basic_Array_Ptr<ACE_INET_Addr> safe_if_addrs (if_addrs); // If the loopback interface is the only interface then include it // in the list of interfaces to query for a hostname, otherwise // exclude it from the list. if (if_cnt == lo_cnt) this->endpoint_count_ = static_cast<CORBA::ULong> (if_cnt); else this->endpoint_count_ = static_cast<CORBA::ULong> (if_cnt - lo_cnt); ACE_NEW_RETURN (this->addrs_, ACE_INET_Addr[this->endpoint_count_], -1); ACE_NEW_RETURN (this->hosts_, char *[this->endpoint_count_], -1); ACE_OS::memset (this->hosts_, 0, sizeof (char*) * this->endpoint_count_); // The number of hosts/interfaces we want to cache may not be the // same as the number of detected interfaces so keep a separate // count. size_t host_cnt = 0; for (size_t i = 0; i < if_cnt; ++i) { // Ignore any loopback interface if there are other // non-loopback interfaces. if (if_cnt != lo_cnt && if_addrs[i].get_ip_address() == INADDR_LOOPBACK) continue; if (this->hostname (orb_core, if_addrs[i], this->hosts_[host_cnt]) != 0) return -1; // Copy the addr. The port is (re)set in // TAO_DIOP_Acceptor::open_i(). if (this->addrs_[host_cnt].set (if_addrs[i]) != 0) return -1; host_cnt++; } return 0; }

---

Member Data Documentation

ACE_INET_Addr* TAO_DIOP_Acceptor::addrs_ [protected]

Array of ACE_INET_Addr instances, each one corresponding to a given network interface. Definition at line 147 of file DIOP_Acceptor.h.

TAO_DIOP_Connection_Handler* TAO_DIOP_Acceptor::connection_handler_ [private]

Definition at line 177 of file DIOP_Acceptor.h.

CORBA::ULong TAO_DIOP_Acceptor::endpoint_count_ [protected]

The number of host names cached in the hosts_ array (equivalent to the number of endpoints opened by this Acceptor). Definition at line 160 of file DIOP_Acceptor.h.

char** TAO_DIOP_Acceptor::hosts_ [protected]

Cache the information about the endpoints serviced by this acceptor. There may in fact be multiple hostnames for this endpoint. For example, if the IP address is INADDR_ANY (0.0.0.0) then there will be possibly a different hostname for each interface. Definition at line 156 of file DIOP_Acceptor.h.

CORBA::Boolean TAO_DIOP_Acceptor::lite_flag_ [protected]

Should we use GIOP lite?? Definition at line 173 of file DIOP_Acceptor.h.

TAO_ORB_Core* TAO_DIOP_Acceptor::orb_core_ [protected]

ORB Core. Definition at line 170 of file DIOP_Acceptor.h.

TAO_GIOP_Message_Version TAO_DIOP_Acceptor::version_ [protected]

The GIOP version for this endpoint @ Theoretically they shouldn't be here!! We need to look at a way to move this out Definition at line 167 of file DIOP_Acceptor.h.

---

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

• DIOP_Acceptor.h
• DIOP_Acceptor.cpp
• DIOP_Acceptor.i

---