TAO/tao/Strategies/DIOP_Profile.cpp

   1 #include "tao/Strategies/DIOP_Profile.h"
   2
   3 #if defined (TAO_HAS_DIOP) && (TAO_HAS_DIOP != 0)
   4
   5 #include "tao/CDR.h"
   6 #include "tao/SystemException.h"
   7 #include "tao/ORB.h"
   8 #include "tao/ORB_Core.h"
   9 #include "tao/debug.h"
  10 #include "tao/IIOP_EndpointsC.h"
  11
  12 #include "ace/OS_NS_stdio.h"
  13 #include "ace/OS_NS_string.h"
  14 #include "ace/os_include/os_netdb.h"
  15 #include "ace/Truncate.h"
  16 #include <cstring>
  17
  18 static const char the_prefix[] = "diop";
  19
  20 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 const char TAO_DIOP_Profile::object_key_delimiter_ = '/';
  23
  24 char
  25 TAO_DIOP_Profile::object_key_delimiter () const
  26 {
  27   return TAO_DIOP_Profile::object_key_delimiter_;
  28 }
  29
  30
  31 TAO_DIOP_Profile::TAO_DIOP_Profile (const ACE_INET_Addr &addr,
  32                                     const TAO::ObjectKey &object_key,
  33                                     const TAO_GIOP_Message_Version &version,
  34                                     TAO_ORB_Core *orb_core)
  35   : TAO_Profile (TAO_TAG_DIOP_PROFILE,
  36                  orb_core,
  37                  object_key,
  38                  version),
  39     endpoint_ (addr,
  40                orb_core->orb_params ()->use_dotted_decimal_addresses ()),
  41     count_ (1)
  42 {
  43 }
  44
  45 TAO_DIOP_Profile::TAO_DIOP_Profile (const char* host,
  46                                     CORBA::UShort port,
  47                                     const TAO::ObjectKey &object_key,
  48                                     const ACE_INET_Addr &addr,
  49                                     const TAO_GIOP_Message_Version &version,
  50                                     TAO_ORB_Core *orb_core)
  51   : TAO_Profile (TAO_TAG_DIOP_PROFILE,
  52                  orb_core,
  53                  object_key,
  54                  version),
  55     endpoint_ (host, port, addr),
  56     count_ (1)
  57 {
  58 }
  59
  60 TAO_DIOP_Profile::TAO_DIOP_Profile (TAO_ORB_Core *orb_core)
  61   : TAO_Profile (TAO_TAG_DIOP_PROFILE,
  62                  orb_core,
  63                  TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)),
  64     endpoint_ (),
  65     count_ (1)
  66 {
  67 }
  68
  69 TAO_DIOP_Profile::~TAO_DIOP_Profile ()
  70 {
  71   // Clean up the list of endpoints since we own it.
  72   // Skip the head, since it is not dynamically allocated.
  73   TAO_Endpoint *tmp = 0;
  74
  75   for (TAO_Endpoint *next = this->endpoint ()->next ();
  76        next != 0;
  77        next = tmp)
  78     {
  79       tmp = next->next ();
  80       delete next;
  81     }
  82 }
  83
  84 // return codes:
  85 // -1 -> error
  86 //  0 -> can't understand this version
  87 //  1 -> success.
  88
  89 int
  90 TAO_DIOP_Profile::decode_profile (TAO_InputCDR& cdr)
  91 {
  92   // @@ NOTE: This code is repeated thrice. Need to factor out in a
  93   // better manner.
  94   // Decode host and port into the <endpoint_>.
  95   if (cdr.read_string (this->endpoint_.host_.out ()) == 0
  96       || cdr.read_ushort (this->endpoint_.port_) == 0)
  97     {
  98       if (TAO_debug_level > 0)
  99         TAOLIB_DEBUG ((LM_DEBUG,
 100                     ACE_TEXT ("TAO (%P|%t) - DIOP_Profile::decode_profile, ")
 101                     ACE_TEXT ("error while decoding host/port\n")));
 102       return -1;
 103     }
 104
 105   if (cdr.good_bit ())
 106     {
 107       // Invalidate the object_addr_ until first access.
 108       this->endpoint_.object_addr_.set_type (-1);
 109
 110       return 1;
 111     }
 112
 113   return -1;
 114 }
 115
 116 void
 117 TAO_DIOP_Profile::parse_string_i (const char *ior)
 118 {
 119   // Pull off the "hostname:port/" part of the objref
 120   // Copy the string because we are going to modify it...
 121   const char *okd = std::strchr (ior, this->object_key_delimiter_);
 122
 123   if (okd == 0 || okd == ior)
 124     {
 125       // No object key delimiter or no hostname specified.
 126       throw ::CORBA::INV_OBJREF (
 127                    CORBA::SystemException::_tao_minor_code (
 128                      TAO::VMCID,
 129                      EINVAL),
 130                    CORBA::COMPLETED_NO);
 131     }
 132
 133   // Length of host string.
 134   CORBA::ULong length_host = 0;
 135
 136   const char *cp_pos = std::strchr (ior, ':');  // Look for a port
 137 #if defined (ACE_HAS_IPV6)
 138   // IPv6 numeric address in host string?
 139   bool ipv6_in_host = false;
 140
 141   // Check if this is a (possibly) IPv6 supporting profile containing a
 142   // decimal IPv6 address representation.
 143   if ((this->version ().major > TAO_MIN_IPV6_IIOP_MAJOR ||
 144        this->version ().minor >= TAO_MIN_IPV6_IIOP_MINOR) &&
 145       ior[0] == '[')
 146     {
 147       // In this case we have to find the end of the numeric address and
 148       // start looking for the port separator from there.
 149       const char *cp_pos_a = std::strchr (ior, ']');
 150       if (cp_pos_a == 0)
 151         {
 152           // No valid IPv6 address specified.
 153           if (TAO_debug_level > 0)
 154             {
 155               TAOLIB_DEBUG ((LM_ERROR,
 156                           ACE_TEXT ("\nTAO (%P|%t) - DIOP_Profile::parse_string_i, ")
 157                           ACE_TEXT ("invalid IPv6 decimal address specified.\n")));
 158             }
 159
 160           throw ::CORBA::INV_OBJREF (
 161                          CORBA::SystemException::_tao_minor_code (
 162                                                                   0,
 163                                                                   EINVAL),
 164                          CORBA::COMPLETED_NO);
 165         }
 166       else
 167         {
 168           if (cp_pos_a[1] == ':')    // Look for a port
 169             cp_pos = cp_pos_a + 1;
 170           else
 171             cp_pos = 0;
 172           ipv6_in_host = true; // host string contains full IPv6 numeric address
 173         }
 174     }
 175 #endif /* ACE_HAS_IPV6 */
 176
 177   if (cp_pos == ior)
 178     {
 179       if (TAO_debug_level > 0)
 180         {
 181           TAOLIB_ERROR ((LM_ERROR,
 182                    ACE_TEXT ("\nTAO (%P|%t) DIOP_Profile: ")
 183                    ACE_TEXT ("Host address may be omited only when no port has been specified.\n")));
 184         }
 185       // No hostname specified!  It is required by the spec.
 186       throw ::CORBA::INV_OBJREF (
 187                    CORBA::SystemException::_tao_minor_code (
 188                      TAO::VMCID,
 189                      EINVAL),
 190                    CORBA::COMPLETED_NO);
 191     }
 192   else if (cp_pos != 0)
 193     {
 194       // A port number or port name was specified.
 195       CORBA::ULong length_port = ACE_Utils::truncate_cast<CORBA::ULong> (okd - cp_pos - 1);
 196
 197       CORBA::String_var tmp = CORBA::string_alloc (length_port);
 198
 199       ACE_OS::strncpy (tmp.inout (), cp_pos + 1, length_port);
 200       tmp[length_port] = '\0';
 201
 202       if (ACE_OS::strspn (tmp.in (), "1234567890") == length_port)
 203         {
 204           this->endpoint_.port_ =
 205             static_cast<CORBA::UShort> (ACE_OS::atoi (tmp.in ()));
 206         }
 207       else
 208         {
 209           ACE_INET_Addr ia;
 210           if (ia.string_to_addr (tmp.in ()) == -1)
 211             {
 212               throw ::CORBA::INV_OBJREF (
 213                              CORBA::SystemException::_tao_minor_code (
 214                                0,
 215                                EINVAL),
 216                              CORBA::COMPLETED_NO);
 217             }
 218           else
 219             {
 220               this->endpoint_.port_ = ia.get_port_number ();
 221             }
 222         }
 223
 224       length_host = ACE_Utils::truncate_cast<CORBA::ULong> (cp_pos - ior);
 225     }
 226   else
 227     length_host = ACE_Utils::truncate_cast<CORBA::ULong> (okd - ior);
 228
 229 #if defined (ACE_HAS_IPV6)
 230   if (ipv6_in_host)
 231     length_host -= 2; // don't store '[' and ']'
 232 #endif /* ACE_HAS_IPV6 */
 233
 234   CORBA::String_var tmp = CORBA::string_alloc (length_host);
 235
 236 #if defined (ACE_HAS_IPV6)
 237   if (ipv6_in_host)
 238     ACE_OS::strncpy (tmp.inout (), ior + 1, length_host);
 239   else
 240 #endif /* ACE_HAS_IPV6 */
 241   // Skip the trailing '/'
 242   ACE_OS::strncpy (tmp.inout (), ior, length_host);
 243   tmp[length_host] = '\0';
 244
 245   this->endpoint_.host_ = tmp._retn ();
 246 #if defined (ACE_HAS_IPV6)
 247   this->endpoint_.is_ipv6_decimal_ = ipv6_in_host;
 248 #endif /* ACE_HAS_IPV6 */
 249
 250   if (ACE_OS::strcmp (this->endpoint_.host_.in (), "") == 0)
 251     {
 252       ACE_INET_Addr host_addr;
 253
 254       char tmp_host [MAXHOSTNAMELEN + 1];
 255
 256       // If no host is specified: assign the default host, i.e. the
 257       // local host.
 258       if (host_addr.get_host_name (tmp_host,
 259                                    sizeof (tmp_host)) != 0)
 260         {
 261           // Can't get the IP address since the INET_Addr wasn't
 262           // initialized.  Just throw an exception.
 263
 264           if (TAO_debug_level > 0)
 265             TAOLIB_DEBUG ((LM_DEBUG,
 266                         ACE_TEXT ("TAO (%P|%t) - ")
 267                         ACE_TEXT ("DIOP_Profile::parse_string_i, ")
 268                         ACE_TEXT ("%p\n\n"),
 269                         ACE_TEXT ("cannot determine hostname")));
 270
 271           // @@ What's the right exception to throw here?
 272           throw ::CORBA::INV_OBJREF (
 273                        CORBA::SystemException::_tao_minor_code (
 274                          TAO::VMCID,
 275                          EINVAL),
 276                        CORBA::COMPLETED_NO);
 277         }
 278       else
 279         this->endpoint_.host_ = CORBA::string_dup (tmp_host);
 280     }
 281
 282   TAO::ObjectKey ok;
 283   TAO::ObjectKey::decode_string_to_sequence (ok,
 284                                              okd + 1);
 285
 286   (void) this->orb_core ()->object_key_table ().bind (ok,
 287                                                       this->ref_object_key_);
 288 }
 289
 290 CORBA::Boolean
 291 TAO_DIOP_Profile::do_is_equivalent (const TAO_Profile *other_profile)
 292 {
 293   const TAO_DIOP_Profile *op =
 294     dynamic_cast<const TAO_DIOP_Profile *> (other_profile);
 295
 296   // Make sure we have a TAO_DIOP_Profile.
 297   if (op == 0)
 298     return 0;
 299
 300   // Check endpoints equivalence.
 301   const TAO_DIOP_Endpoint *other_endp = &op->endpoint_;
 302   for (TAO_DIOP_Endpoint *endp = &this->endpoint_;
 303        endp != 0;
 304        endp = endp->next_)
 305     {
 306       if (endp->is_equivalent (other_endp))
 307         other_endp = other_endp->next_;
 308       else
 309         return false;
 310     }
 311
 312   return true;
 313 }
 314
 315 CORBA::ULong
 316 TAO_DIOP_Profile::hash (CORBA::ULong max)
 317 {
 318   // Get the hashvalue for all endpoints.
 319   CORBA::ULong hashval = 0;
 320   for (TAO_DIOP_Endpoint *endp = &this->endpoint_;
 321        endp != 0;
 322        endp = endp->next_)
 323     {
 324       hashval += endp->hash ();
 325     }
 326
 327   hashval += this->version_.minor;
 328   hashval += this->tag ();
 329
 330   const TAO::ObjectKey &ok =
 331     this->ref_object_key_->object_key ();
 332
 333   if (ok.length () >= 4)
 334     {
 335       hashval += ok[1];
 336       hashval += ok[3];
 337     }
 338
 339   hashval += this->hash_service_i (max);
 340
 341   return hashval % max;
 342 }
 343
 344 TAO_Endpoint*
 345 TAO_DIOP_Profile::endpoint ()
 346 {
 347   return &this->endpoint_;
 348 }
 349
 350 CORBA::ULong
 351 TAO_DIOP_Profile::endpoint_count () const
 352 {
 353   return this->count_;
 354 }
 355
 356 void
 357 TAO_DIOP_Profile::add_endpoint (TAO_DIOP_Endpoint *endp)
 358 {
 359   endp->next_ = this->endpoint_.next_;
 360   this->endpoint_.next_ = endp;
 361
 362   this->count_++;
 363 }
 364
 365 char *
 366 TAO_DIOP_Profile::to_string () const
 367 {
 368   // corbaloc:diop:1.2@host:port,diop:1.2@host:port,.../key
 369
 370   CORBA::String_var key;
 371   TAO::ObjectKey::encode_sequence_to_string (key.inout (),
 372                                              this->ref_object_key_->object_key ());
 373
 374   size_t buflen = (
 375        8 /* "corbaloc" */ +
 376        1 /* colon separator */ +
 377        1 /* object key separator */ +
 378        ACE_OS::strlen (key.in ()));
 379   size_t pfx_len = (
 380        ACE_OS::strlen (::the_prefix) /* "diop" */ +
 381        1 /* colon separator */);
 382
 383  const TAO_DIOP_Endpoint *endp = 0;
 384  for (endp = &this->endpoint_; endp != 0; endp = endp->next_)
 385    {
 386       buflen += (
 387           pfx_len +
 388           1 /* major version */ +
 389           1 /* decimal point */ +
 390           1 /* minor version */ +
 391           1 /* `@' character */ +
 392           ACE_OS::strlen (endp->host ()) +
 393           1 /* colon separator */ +
 394           5 /* port number */ +
 395           1 /* comma */);
 396 #if defined (ACE_HAS_IPV6)
 397       if (endp->is_ipv6_decimal_)
 398         buflen += 2; // room for '[' and ']'
 399 #endif /* ACE_HAS_IPV6 */
 400    }
 401
 402   static const char digits [] = "0123456789";
 403
 404   char * buf = CORBA::string_alloc (static_cast<CORBA::ULong> (buflen));
 405
 406   ACE_OS::strcpy (buf, "corbaloc:");
 407
 408   for (endp = &this->endpoint_; endp != 0; endp = endp->next_)
 409     {
 410       if (&this->endpoint_ != endp)
 411       ACE_OS::strcat (buf, ",");
 412
 413 #if defined (ACE_HAS_IPV6)
 414       if (endp->is_ipv6_decimal_)
 415         {
 416           // Don't publish scopeid if included.
 417           ACE_CString tmp (endp->host ());
 418           ACE_CString::size_type pos = tmp.find ('%');
 419           if (pos != ACE_CString::npos)
 420             {
 421               tmp = tmp.substr (0, pos + 1);
 422               tmp[pos] = '\0';
 423             }
 424           ACE_OS::sprintf (buf + ACE_OS::strlen (buf),
 425                   "%s:%c.%c@[%s]:%d",
 426                   ::the_prefix,
 427                   digits [this->version_.major],
 428                   digits [this->version_.minor],
 429                   tmp.c_str (),
 430                   endp->port ());
 431         }
 432       else
 433 #endif
 434       ACE_OS::sprintf (buf + ACE_OS::strlen (buf),
 435               "%s:%c.%c@%s:%d",
 436               ::the_prefix,
 437               digits [this->version_.major],
 438               digits [this->version_.minor],
 439               endp->host (),
 440               endp->port ());
 441   }
 442   ACE_OS::sprintf (buf + ACE_OS::strlen (buf),
 443                    "%c%s",
 444                    this->object_key_delimiter_,
 445                    key.in ());
 446
 447   return buf;
 448 }
 449
 450 const char *
 451 TAO_DIOP_Profile::prefix ()
 452 {
 453   return ::the_prefix;
 454 }
 455
 456 void
 457 TAO_DIOP_Profile::create_profile_body (TAO_OutputCDR &encap) const
 458 {
 459   encap.write_octet (TAO_ENCAP_BYTE_ORDER);
 460
 461   // The GIOP version
 462   encap.write_octet (this->version_.major);
 463   encap.write_octet (this->version_.minor);
 464
 465   // STRING hostname from profile
 466 #if defined (ACE_HAS_IPV6)
 467   // For IPv6 decimal addresses make sure the possibly included scopeid
 468   // is not published as this has only local meaning.
 469   const char* host;
 470   const char* pos;
 471   if (this->endpoint_.is_ipv6_decimal_ &&
 472       (pos = std::strchr (host = this->endpoint_.host (), '%')) != 0)
 473     {
 474       ACE_CString tmp;
 475       size_t len = pos - host;
 476       tmp.set (this->endpoint_.host (), len, 1);
 477       encap.write_string (tmp.c_str ());
 478     }
 479   else
 480 #endif /* ACE_HAS_IPV6 */
 481   encap.write_string (this->endpoint_.host ());
 482
 483   // UNSIGNED SHORT port number
 484   encap.write_ushort (this->endpoint_.port ());
 485
 486   // OCTET SEQUENCE for object key
 487   if (this->ref_object_key_)
 488     encap << this->ref_object_key_->object_key ();
 489   else
 490     {
 491       TAOLIB_ERROR ((LM_ERROR,
 492                   "TAO (%P|%t) - DIOP_Profile::create_profile_body, "
 493                   "no object key marshalled\n"));
 494     }
 495
 496   if (this->version_.major > 1
 497       || this->version_.minor > 0)
 498     this->tagged_components ().encode (encap);
 499 }
 500
 501 int
 502 TAO_DIOP_Profile::encode_endpoints ()
 503 {
 504   // Create a data structure and fill it with endpoint info for wire
 505   // transfer.
 506   // We include information for the head of the list
 507   // together with other endpoints because even though its addressing
 508   // info is transmitted using standard ProfileBody components, its
 509   // priority is not!
 510
 511   TAO::IIOPEndpointSequence endpoints;
 512   endpoints.length (this->count_);
 513
 514   const TAO_DIOP_Endpoint *endpoint = &this->endpoint_;
 515   for (CORBA::ULong i = 0;
 516        i < this->count_;
 517        ++i)
 518     {
 519 #if defined (ACE_HAS_IPV6)
 520       if (endpoint->is_ipv6_decimal_)
 521         {
 522           // Don't publish scopeid if included.
 523           ACE_CString tmp (endpoint->host ());
 524           ACE_CString::size_type pos = tmp.find ('%');
 525           if (pos != ACE_CString::npos)
 526             {
 527               tmp = tmp.substr (0, pos + 1);
 528               tmp[pos] = '\0';
 529               endpoints[i].host = tmp.c_str ();
 530             }
 531           else
 532             endpoints[i].host = tmp.c_str ();
 533         }
 534       else
 535 #endif /* ACE_HAS_IPV6 */
 536       endpoints[i].host = endpoint->host ();
 537       endpoints[i].port = endpoint->port ();
 538       endpoints[i].priority = endpoint->priority ();
 539
 540       endpoint = endpoint->next_;
 541     }
 542
 543   // Encode the data structure.
 544   TAO_OutputCDR out_cdr;
 545   if ((out_cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)) == 0
 546       || (out_cdr << endpoints) == 0)
 547     return -1;
 548
 549   this->set_tagged_components (out_cdr);
 550
 551   return  0;
 552 }
 553
 554 int
 555 TAO_DIOP_Profile::decode_endpoints ()
 556 {
 557   IOP::TaggedComponent tagged_component;
 558   tagged_component.tag = TAO_TAG_ENDPOINTS;
 559
 560   if (this->tagged_components_.get_component (tagged_component))
 561     {
 562       const CORBA::Octet *buf =
 563         tagged_component.component_data.get_buffer ();
 564
 565       TAO_InputCDR in_cdr (reinterpret_cast<const char*> (buf),
 566                            tagged_component.component_data.length ());
 567
 568       // Extract the Byte Order.
 569       CORBA::Boolean byte_order;
 570       if ((in_cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
 571         return -1;
 572       in_cdr.reset_byte_order (static_cast<int> (byte_order));
 573
 574       // Extract endpoints sequence.
 575       TAO::IIOPEndpointSequence endpoints;
 576
 577       if (! (in_cdr >> endpoints))
 578         return -1;
 579
 580       // Get the priority of the first endpoint (head of the list.
 581       // It's other data is extracted as part of the standard profile
 582       // decoding.
 583       this->endpoint_.priority (endpoints[0].priority);
 584
 585       // Use information extracted from the tagged component to
 586       // populate the profile.  Skip the first endpoint, since it is
 587       // always extracted through standard profile body.  Also, begin
 588       // from the end of the sequence to preserve endpoint order,
 589       // since <add_endpoint> method reverses the order of endpoints
 590       // in the list.
 591       for (CORBA::ULong i = endpoints.length () - 1;
 592            i > 0;
 593            --i)
 594         {
 595           TAO_DIOP_Endpoint *endpoint = 0;
 596           ACE_NEW_RETURN (endpoint,
 597                           TAO_DIOP_Endpoint (endpoints[i].host,
 598                                              endpoints[i].port,
 599                                              endpoints[i].priority),
 600                           -1);
 601
 602           this->add_endpoint (endpoint);
 603         }
 604     }
 605
 606   return 0;
 607 }
 608
 609 TAO_END_VERSIONED_NAMESPACE_DECL
 610
 611 #endif /* TAO_HAS_DIOP && TAO_HAS_DIOP != 0 */