TAO/tao/Strategies/DIOP_Endpoint.cpp

   1 #include "tao/Strategies/DIOP_Endpoint.h"
   2
   3 #if defined (TAO_HAS_DIOP) && (TAO_HAS_DIOP != 0)
   4
   5 #include "tao/Strategies/DIOP_Connection_Handler.h"
   6 #include "tao/debug.h"
   7 #include "tao/ORB_Constants.h"
   8
   9 #include "ace/OS_NS_stdio.h"
  10 #include "ace/OS_NS_string.h"
  11
  12 #if !defined (__ACE_INLINE__)
  13 # include "tao/Strategies/DIOP_Endpoint.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 #include "ace/os_include/os_netdb.h"
  17 #include <cstring>
  18
  19 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  20
  21 TAO_DIOP_Endpoint::TAO_DIOP_Endpoint (const ACE_INET_Addr &addr,
  22                                       int use_dotted_decimal_addresses)
  23
  24   : TAO_Endpoint (TAO_TAG_DIOP_PROFILE)
  25     , host_ ()
  26     , port_ (0)
  27 #if defined (ACE_HAS_IPV6)
  28     , is_ipv6_decimal_ (false)
  29 #endif /* ACE_HAS_IPV6 */
  30     , object_addr_ (addr)
  31     , object_addr_set_ (false)
  32     , next_ (0)
  33 {
  34   this->set (addr, use_dotted_decimal_addresses);
  35 }
  36
  37 TAO_DIOP_Endpoint::TAO_DIOP_Endpoint (const char *host,
  38                                       CORBA::UShort port,
  39                                       const ACE_INET_Addr &addr,
  40                                       CORBA::Short priority)
  41   : TAO_Endpoint (TAO_TAG_DIOP_PROFILE,
  42                   priority)
  43     , host_ ()
  44     , port_ (port)
  45 #if defined (ACE_HAS_IPV6)
  46     , is_ipv6_decimal_ (false)
  47 #endif /* ACE_HAS_IPV6 */
  48     , object_addr_ (addr)
  49     , object_addr_set_ (false)
  50     , next_ (0)
  51 {
  52   this->host (host); // With IPv6 performs check for decimal address
  53 }
  54
  55 TAO_DIOP_Endpoint::TAO_DIOP_Endpoint ()
  56   : TAO_Endpoint (TAO_TAG_DIOP_PROFILE),
  57     host_ (),
  58     port_ (0),
  59 #if defined (ACE_HAS_IPV6)
  60     is_ipv6_decimal_ (false),
  61 #endif /* ACE_HAS_IPV6 */
  62     object_addr_ (),
  63     object_addr_set_ (false),
  64     next_ (0)
  65 {
  66 }
  67
  68 TAO_DIOP_Endpoint::TAO_DIOP_Endpoint (const char *host,
  69                                       CORBA::UShort port,
  70                                       CORBA::Short priority)
  71   : TAO_Endpoint (TAO_TAG_DIOP_PROFILE, priority),
  72     host_ (),
  73     port_ (port),
  74 #if defined (ACE_HAS_IPV6)
  75     is_ipv6_decimal_ (false),
  76 #endif /* ACE_HAS_IPV6 */
  77     object_addr_ (),
  78     object_addr_set_ (false),
  79     next_ (0)
  80 {
  81   this->host (host); // With IPv6 performs check for decimal address
  82 }
  83
  84 int
  85 TAO_DIOP_Endpoint::set (const ACE_INET_Addr &addr,
  86                         int use_dotted_decimal_addresses)
  87 {
  88   char tmp_host[MAXHOSTNAMELEN + 1];
  89
  90 #if defined (ACE_HAS_IPV6)
  91   this->is_ipv6_decimal_ = false; // Reset
  92 #endif /* ACE_HAS_IPV6 */
  93
  94   if (use_dotted_decimal_addresses
  95       || addr.get_host_name (tmp_host, sizeof (tmp_host)) != 0)
  96     {
  97       if (use_dotted_decimal_addresses == 0 && TAO_debug_level > 5)
  98         {
  99           TAOLIB_DEBUG ((LM_DEBUG,
 100                       ACE_TEXT ("TAO (%P|%t) - DIOP_Endpoint::set, ")
 101                       ACE_TEXT ("%p\n"),
 102                       ACE_TEXT ("cannot determine hostname")));
 103         }
 104
 105       const char *tmp = addr.get_host_addr ();
 106       if (tmp == 0)
 107         {
 108           if (TAO_debug_level > 0)
 109             TAOLIB_DEBUG ((LM_DEBUG,
 110                         ACE_TEXT ("TAO (%P|%t) - ")
 111                         ACE_TEXT ("DIOP_Endpoint::set, ")
 112                         ACE_TEXT ("%p\n"),
 113                         ACE_TEXT ("cannot determine hostname\n")));
 114           return -1;
 115         }
 116       else
 117         {
 118           this->host_ = tmp;
 119 #if defined (ACE_HAS_IPV6)
 120           if (addr.get_type () == PF_INET6)
 121             this->is_ipv6_decimal_ = true;
 122 #endif /* ACE_HAS_IPV6 */
 123         }
 124     }
 125   else
 126     this->host_ = CORBA::string_dup (tmp_host);
 127
 128   this->port_ = addr.get_port_number ();
 129
 130   return 0;
 131 }
 132
 133 int
 134 TAO_DIOP_Endpoint::addr_to_string (char *buffer, size_t length)
 135 {
 136   size_t actual_len =
 137     ACE_OS::strlen (this->host_.in ()) // chars in host name
 138     + sizeof (':')                     // delimiter
 139     + ACE_OS::strlen ("65536")         // max port
 140     + sizeof ('\0');
 141
 142 #if defined (ACE_HAS_IPV6)
 143   if (this->is_ipv6_decimal_)
 144     actual_len += 2; // '[' + ']'
 145 #endif /* ACE_HAS_IPV6 */
 146
 147   if (length < actual_len)
 148     return -1;
 149
 150 #if defined (ACE_HAS_IPV6)
 151   if (this->is_ipv6_decimal_)
 152     ACE_OS::sprintf (buffer, "[%s]:%d",
 153                      this->host_.in (), this->port_);
 154   else
 155 #endif /* ACE_HAS_IPV6 */
 156   ACE_OS::sprintf (buffer, "%s:%d",
 157                    this->host_.in (), this->port_);
 158
 159   return 0;
 160 }
 161
 162 const char *
 163 TAO_DIOP_Endpoint::host (const char *h)
 164 {
 165   this->host_ = h;
 166 #if defined (ACE_HAS_IPV6)
 167   if (std::strchr (h, ':') != 0)
 168     this->is_ipv6_decimal_ = true;
 169 #endif /* ACE_HAS_IPV6 */
 170
 171   return this->host_.in ();
 172 }
 173
 174 TAO_Endpoint *
 175 TAO_DIOP_Endpoint::next ()
 176 {
 177   return this->next_;
 178 }
 179
 180 TAO_Endpoint *
 181 TAO_DIOP_Endpoint::duplicate ()
 182 {
 183   TAO_DIOP_Endpoint *endpoint = 0;
 184
 185   ACE_NEW_RETURN (endpoint,
 186                   TAO_DIOP_Endpoint (this->host_.in (),
 187                                      this->port_,
 188                                      this->object_addr_,
 189                                      this->priority ()),
 190                   0);
 191
 192   return endpoint;
 193 }
 194
 195 CORBA::Boolean
 196 TAO_DIOP_Endpoint::is_equivalent (const TAO_Endpoint *other_endpoint)
 197 {
 198   TAO_Endpoint *endpt = const_cast<TAO_Endpoint *> (other_endpoint);
 199
 200   TAO_DIOP_Endpoint *endpoint = dynamic_cast<TAO_DIOP_Endpoint *> (endpt);
 201   if (endpoint == 0)
 202     return 0;
 203
 204   return (this->port () == endpoint->port ()
 205           && ACE_OS::strcmp (this->host (), endpoint->host ()) == 0);
 206 }
 207
 208 CORBA::ULong
 209 TAO_DIOP_Endpoint::hash ()
 210 {
 211   if (this->hash_val_ != 0)
 212     return this->hash_val_;
 213
 214   {
 215     ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
 216                       guard,
 217                       this->addr_lookup_lock_,
 218                       this->hash_val_);
 219     // .. DCL
 220     if (this->hash_val_ != 0)
 221       return this->hash_val_;
 222
 223     this->hash_val_ =
 224       ACE::hash_pjw (this->host ()) + this->port ();
 225   }
 226
 227   return this->hash_val_;
 228 }
 229
 230 const ACE_INET_Addr &
 231 TAO_DIOP_Endpoint::object_addr () const
 232 {
 233   // The object_addr_ is initialized here, rather than at IOR decode
 234   // time for several reasons:
 235   //   1. A request on the object may never be invoked.
 236   //   2. The DNS setup may have changed dynamically.
 237   //   ...etc..
 238
 239   // Double checked locking optimization.
 240   if (!this->object_addr_set_)
 241     {
 242       ACE_GUARD_RETURN (TAO_SYNCH_MUTEX,
 243                         guard,
 244                         this->addr_lookup_lock_,
 245                         this->object_addr_ );
 246
 247       if (!this->object_addr_set_)
 248         {
 249           (void) this->object_addr_i ();
 250         }
 251     }
 252   return this->object_addr_;
 253 }
 254
 255 void
 256 TAO_DIOP_Endpoint::object_addr_i () const
 257 {
 258   // We should have already held the lock
 259
 260 #if defined (ACE_HAS_IPV6)
 261   bool is_ipv4_decimal_ = false;
 262   if (!this->is_ipv6_decimal_)
 263     is_ipv4_decimal_ =
 264       ACE_OS::strspn (this->host_.in (), ".0123456789") ==
 265       ACE_OS::strlen (this->host_.in ());
 266
 267   // If this is *not* an IPv4 decimal address at first try to
 268   // resolve the address as an IPv6 address; if that fails
 269   // (or it's an IPv4 address) and the address is *not* an IPv6
 270   // decimal address try to resolve it as an IPv4 address.
 271   if ((is_ipv4_decimal_ ||
 272         this->object_addr_.set (this->port_,
 273                                 this->host_.in (),
 274                                 1,
 275                                 AF_INET6) == -1) &&
 276       (this->is_ipv6_decimal_ ||
 277         this->object_addr_.set (this->port_,
 278                               this->host_.in (),
 279                               1,
 280                               AF_INET) == -1))
 281 #else
 282   if (this->object_addr_.set (this->port_,
 283                               this->host_.in ()) == -1)
 284 #endif /* ACE_HAS_IPV6 */
 285     {
 286       // If this call fails, it most likely due a hostname
 287       // lookup failure caused by a DNS misconfiguration.  If
 288       // a request is made to the object at the given host and
 289       // port, then a CORBA::TRANSIENT() exception should be
 290       // thrown.
 291
 292       // Invalidate the ACE_INET_Addr.  This is used as a flag
 293       // to denote that ACE_INET_Addr initialization failed.
 294       this->object_addr_.set_type (-1);
 295     }
 296   else
 297     {
 298       this->object_addr_set_ = true;
 299     }
 300 }
 301
 302 TAO_END_VERSIONED_NAMESPACE_DECL
 303
 304 #endif /* TAO_HAS_DIOP && TAO_HAS_DIOP != 0 */