TAO/tao/Strategies/SHMIOP_Profile.cpp

   1 #include "tao/Strategies/SHMIOP_Profile.h"
   2
   3 #if defined (TAO_HAS_SHMIOP) && (TAO_HAS_SHMIOP != 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 prefix_[] = "shmiop";
  19
  20 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  21
  22 const char TAO_SHMIOP_Profile::object_key_delimiter_ = '/';
  23
  24 char
  25 TAO_SHMIOP_Profile::object_key_delimiter () const
  26 {
  27   return TAO_SHMIOP_Profile::object_key_delimiter_;
  28 }
  29
  30 TAO_SHMIOP_Profile::TAO_SHMIOP_Profile (const ACE_MEM_Addr &addr,
  31                                         const TAO::ObjectKey &object_key,
  32                                         const TAO_GIOP_Message_Version &version,
  33                                         TAO_ORB_Core *orb_core)
  34   : TAO_Profile (TAO_TAG_SHMEM_PROFILE,
  35                  orb_core,
  36                  object_key,
  37                  version),
  38     endpoint_ (addr,
  39                orb_core->orb_params ()->use_dotted_decimal_addresses ()),
  40     count_ (1)
  41 {
  42 }
  43
  44 TAO_SHMIOP_Profile::TAO_SHMIOP_Profile (const char* host,
  45                                         CORBA::UShort port,
  46                                         const TAO::ObjectKey &object_key,
  47                                         const ACE_INET_Addr &addr,
  48                                         const TAO_GIOP_Message_Version &version,
  49                                         TAO_ORB_Core *orb_core)
  50   : TAO_Profile (TAO_TAG_SHMEM_PROFILE,
  51                  orb_core,
  52                  object_key,
  53                  version),
  54     endpoint_ (host, port, addr),
  55     count_ (1)
  56 {
  57 }
  58
  59 TAO_SHMIOP_Profile::TAO_SHMIOP_Profile (TAO_ORB_Core *orb_core)
  60   : TAO_Profile (TAO_TAG_SHMEM_PROFILE,
  61                  orb_core,
  62                  TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)),
  63     endpoint_ (),
  64     count_ (1)
  65 {
  66 }
  67
  68 TAO_SHMIOP_Profile::~TAO_SHMIOP_Profile ()
  69 {
  70   // Clean up the list of endpoints since we own it.
  71   // Skip the head, since it is not dynamically allocated.
  72   TAO_Endpoint *tmp = 0;
  73
  74   for (TAO_Endpoint *next = this->endpoint ()->next ();
  75        next != 0;
  76        next = tmp)
  77     {
  78       tmp = next->next ();
  79       delete next;
  80     }
  81 }
  82
  83 TAO_Endpoint*
  84 TAO_SHMIOP_Profile::endpoint ()
  85 {
  86   return &this->endpoint_;
  87 }
  88
  89 CORBA::ULong
  90 TAO_SHMIOP_Profile::endpoint_count () const
  91 {
  92   return this->count_;
  93 }
  94
  95 // return codes:
  96 // -1 -> error
  97 //  0 -> can't understand this version
  98 //  1 -> success.
  99 int
 100 TAO_SHMIOP_Profile::decode_profile (TAO_InputCDR& cdr)
 101 {
 102   // Decode host and port into the <endpoint_>.
 103   if (cdr.read_string (this->endpoint_.host_.out ()) == 0
 104       || cdr.read_ushort (this->endpoint_.port_) == 0)
 105     {
 106       if (TAO_debug_level > 0)
 107         {
 108           TAOLIB_DEBUG ((LM_DEBUG,
 109                       ACE_TEXT ("TAO (%P|%t) SHMIOP_Profile::decode - ")
 110                       ACE_TEXT ("error while decoding host/port")));
 111         }
 112       return -1;
 113     }
 114
 115   if (cdr.good_bit ())
 116     {
 117       // Invalidate the object_addr_ until first access.
 118       this->endpoint_.object_addr_.set_type (-1);
 119
 120       return 1;
 121     }
 122
 123   return -1;
 124 }
 125
 126 void
 127 TAO_SHMIOP_Profile::parse_string_i (const char *string)
 128 {
 129   // Pull off the "hostname:port/" part of the objref
 130   // Copy the string because we are going to modify it...
 131   CORBA::String_var copy (string);
 132
 133   char *start = copy.inout ();
 134   char *cp = std::strchr (start, ':');  // Look for a port
 135
 136   if (cp == 0)
 137     {
 138       // No host/port delimiter!
 139       throw ::CORBA::INV_OBJREF (
 140                    CORBA::SystemException::_tao_minor_code (
 141                      TAO::VMCID,
 142                      EINVAL),
 143                    CORBA::COMPLETED_NO);
 144     }
 145
 146   char *okd = std::strchr (start, this->object_key_delimiter_);
 147
 148   if (okd == 0)
 149     {
 150       // No object key delimiter!
 151       throw ::CORBA::INV_OBJREF (
 152                    CORBA::SystemException::_tao_minor_code (
 153                      TAO::VMCID,
 154                      EINVAL),
 155                    CORBA::COMPLETED_NO);
 156     }
 157
 158   // Don't increment the pointer 'cp' directly since we still need
 159   // to use it immediately after this block.
 160
 161   CORBA::ULong length = ACE_Utils::truncate_cast<CORBA::ULong> (okd - (cp + 1));
 162   // Don't allocate space for the colon ':'.
 163
 164   CORBA::String_var tmp = CORBA::string_alloc (length);
 165
 166   ACE_OS::strncpy (tmp.inout (), cp + 1, length);
 167   tmp[length] = '\0';
 168
 169   if (ACE_OS::strspn (tmp.in (), "1234567890") == length)
 170     {
 171       this->endpoint_.port_ =
 172         static_cast <CORBA::UShort> (ACE_OS::atoi (tmp.in ()));
 173     }
 174   else
 175     {
 176       ACE_INET_Addr ia;
 177       if (ia.string_to_addr (tmp.in ()) == -1)
 178         {
 179           throw ::CORBA::INV_OBJREF (
 180               CORBA::SystemException::_tao_minor_code (
 181                   TAO::VMCID,
 182                   EINVAL),
 183               CORBA::COMPLETED_NO);
 184         }
 185       else
 186         {
 187           this->endpoint_.port_ = ia.get_port_number ();
 188         }
 189     }
 190
 191   length = ACE_Utils::truncate_cast<CORBA::ULong> (cp - start);
 192
 193   tmp = CORBA::string_alloc (length);
 194
 195   ACE_OS::strncpy (tmp.inout (), start, length);
 196   tmp[length] = '\0';
 197
 198   this->endpoint_.host_ = tmp._retn ();
 199
 200   ACE_INET_Addr host_addr;
 201
 202   if (ACE_OS::strcmp (this->endpoint_.host_.in (), "") == 0)
 203     {
 204       char tmp_host [MAXHOSTNAMELEN + 1];
 205
 206       // If no host is specified: assign the default host : the local host.
 207       if (host_addr.get_host_name (tmp_host,
 208                                    sizeof (tmp_host)) != 0)
 209       {
 210         const char *tmp = host_addr.get_host_addr ();
 211         if (tmp == 0)
 212           {
 213             if (TAO_debug_level > 0)
 214               TAOLIB_DEBUG ((LM_DEBUG,
 215                           ACE_TEXT ("\n\nTAO (%P|%t) ")
 216                           ACE_TEXT ("SHMIOP_Profile::parse_string ")
 217                           ACE_TEXT ("- %p\n\n"),
 218                           ACE_TEXT ("cannot determine hostname")));
 219
 220             // @@ What's the right exception to throw here?
 221             throw ::CORBA::INV_OBJREF (
 222                          CORBA::SystemException::_tao_minor_code (
 223                            TAO::VMCID,
 224                            EINVAL),
 225                          CORBA::COMPLETED_NO);
 226           }
 227         else
 228           this->endpoint_.host_ = tmp;
 229       }
 230       else
 231         {
 232           this->endpoint_.host_ = (const char *) tmp_host;
 233         }
 234     }
 235
 236   if (this->endpoint_.object_addr_.set (this->endpoint_.port_,
 237                                         this->endpoint_.host_.in ()) == -1)
 238     {
 239       if (TAO_debug_level > 0)
 240         {
 241           TAOLIB_DEBUG ((LM_DEBUG,
 242                       ACE_TEXT ("TAO (%P|%t) SHMIOP_Profile::parse_string () -\n")
 243                       ACE_TEXT ("TAO (%P|%t) ACE_INET_Addr::set () failed")));
 244         }
 245
 246       // @@ What's the right exception to throw here?
 247       throw ::CORBA::INV_OBJREF (
 248                    CORBA::SystemException::_tao_minor_code (
 249                      TAO::VMCID,
 250                      EINVAL),
 251                    CORBA::COMPLETED_NO);
 252     }
 253
 254   TAO::ObjectKey ok;
 255   TAO::ObjectKey::decode_string_to_sequence (ok,
 256                                              okd + 1);  // increment past the object key separator
 257
 258   (void) this->orb_core ()->object_key_table ().bind (ok,
 259                                                       this->ref_object_key_);
 260 }
 261
 262 CORBA::Boolean
 263 TAO_SHMIOP_Profile::do_is_equivalent (const TAO_Profile *other_profile)
 264 {
 265   const TAO_SHMIOP_Profile *op =
 266     dynamic_cast <const TAO_SHMIOP_Profile *> (other_profile);
 267
 268   if (op == 0)
 269     return 0;
 270
 271   // Check endpoints equivalence.
 272   const TAO_SHMIOP_Endpoint *other_endp = &op->endpoint_;
 273   for (TAO_SHMIOP_Endpoint *endp = &this->endpoint_;
 274        endp != 0;
 275        endp = endp->next_)
 276     {
 277       if (endp->is_equivalent (other_endp))
 278         other_endp = other_endp->next_;
 279       else
 280         return 0;
 281     }
 282
 283   return 1;
 284 }
 285
 286 CORBA::ULong
 287 TAO_SHMIOP_Profile::hash (CORBA::ULong max)
 288 {
 289   // Get the hashvalue for all endpoints.
 290   CORBA::ULong hashval = 0;
 291   for (TAO_SHMIOP_Endpoint *endp = &this->endpoint_;
 292        endp != 0;
 293        endp = endp->next_)
 294     {
 295       hashval += endp->hash ();
 296     }
 297
 298   hashval += this->version_.minor;
 299   hashval += this->tag ();
 300
 301   const TAO::ObjectKey &ok =
 302     this->ref_object_key_->object_key ();
 303
 304   if (ok.length () >= 4)
 305     {
 306       hashval += ok[1];
 307       hashval += ok[3];
 308     }
 309
 310   hashval += this->hash_service_i (max);
 311
 312   return hashval % max;
 313 }
 314
 315 void
 316 TAO_SHMIOP_Profile::add_endpoint (TAO_SHMIOP_Endpoint *endp)
 317 {
 318   endp->next_ = this->endpoint_.next_;
 319   this->endpoint_.next_ = endp;
 320
 321   this->count_++;
 322 }
 323
 324 char *
 325 TAO_SHMIOP_Profile::to_string () const
 326 {
 327   CORBA::String_var key;
 328   TAO::ObjectKey::encode_sequence_to_string (key.inout(),
 329                                              this->ref_object_key_->object_key ());
 330
 331   size_t buflen = (8 /* corbaloc */ +
 332                    1 /* colon separator */ +
 333                    ACE_OS::strlen (::prefix_) +
 334                    1 /* colon separator */ +
 335                    1 /* major version */ +
 336                    1 /* decimal point */ +
 337                    1 /* minor version */ +
 338                    1 /* `@' character */ +
 339                    ACE_OS::strlen (this->endpoint_.host ()) +
 340                    1 /* colon separator */ +
 341                    5 /* port number */ +
 342                    1 /* object key separator */ +
 343                    ACE_OS::strlen (key.in ()));
 344
 345   char * buf = CORBA::string_alloc (static_cast <CORBA::ULong> (buflen));
 346
 347   static const char digits [] = "0123456789";
 348
 349   ACE_OS::sprintf (buf,
 350                    "corbaloc:%s:%c.%c@%s:%d%c%s",
 351                    ::prefix_,
 352                    digits [this->version_.major],
 353                    digits [this->version_.minor],
 354                    this->endpoint_.host (),
 355                    this->endpoint_.port (),
 356                    this->object_key_delimiter_,
 357                    key.in ());
 358   return buf;
 359 }
 360
 361 const char *
 362 TAO_SHMIOP_Profile::prefix ()
 363 {
 364   return ::prefix_;
 365 }
 366
 367 void
 368 TAO_SHMIOP_Profile::create_profile_body (TAO_OutputCDR &encap) const
 369 {
 370   encap.write_octet (TAO_ENCAP_BYTE_ORDER);
 371
 372   // The GIOP version
 373   encap.write_octet (this->version_.major);
 374   encap.write_octet (this->version_.minor);
 375
 376   // STRING hostname from profile
 377   encap.write_string (this->endpoint_.host ());
 378
 379   // UNSIGNED SHORT port number
 380   encap.write_ushort (this->endpoint_.port ());
 381
 382   // OCTET SEQUENCE for object key
 383   if (this->ref_object_key_)
 384     encap << this->ref_object_key_->object_key ();
 385   else
 386     {
 387       TAOLIB_ERROR ((LM_ERROR,
 388                   "(%P|%t) TAO - SHMIOP_Profile::create_profile_body "
 389                   "no object key marshalled\n"));
 390     }
 391
 392   if (this->version_.major > 1
 393       || this->version_.minor > 0)
 394     this->tagged_components ().encode (encap);
 395 }
 396
 397 int
 398 TAO_SHMIOP_Profile::encode_endpoints ()
 399 {
 400   // Create a data structure and fill it with endpoint info for wire
 401   // transfer.
 402   // We include information for the head of the list
 403   // together with other endpoints because even though its addressing
 404   // info is transmitted using standard ProfileBody components, its
 405   // priority is not!
 406   TAO::IIOPEndpointSequence endpoints;
 407   endpoints.length (this->count_);
 408
 409   TAO_SHMIOP_Endpoint *endpoint = &this->endpoint_;
 410   for (CORBA::ULong i = 0;
 411        i < this->count_;
 412        ++i)
 413     {
 414       endpoints[i].host = endpoint->host ();
 415       endpoints[i].port = endpoint->port ();
 416       endpoints[i].priority = endpoint->priority ();
 417
 418       endpoint = endpoint->next_;
 419     }
 420
 421   // Encode the data structure.
 422   TAO_OutputCDR out_cdr;
 423   if ((out_cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)) == 0
 424       || (out_cdr << endpoints) == 0)
 425     return -1;
 426   size_t length = out_cdr.total_length ();
 427
 428   IOP::TaggedComponent tagged_component;
 429   tagged_component.tag = TAO_TAG_ENDPOINTS;
 430   tagged_component.component_data.length (static_cast <CORBA::ULong>(length));
 431   CORBA::Octet *buf =
 432     tagged_component.component_data.get_buffer ();
 433
 434   for (const ACE_Message_Block *iterator = out_cdr.begin ();
 435        iterator != 0;
 436        iterator = iterator->cont ())
 437     {
 438       size_t i_length = iterator->length ();
 439       ACE_OS::memcpy (buf, iterator->rd_ptr (), i_length);
 440
 441       buf += i_length;
 442     }
 443
 444   // Add component with encoded endpoint data to this profile's
 445   // TaggedComponents.
 446   tagged_components_.set_component (tagged_component);
 447
 448   return 0;
 449 }
 450
 451 int
 452 TAO_SHMIOP_Profile::decode_endpoints ()
 453 {
 454   IOP::TaggedComponent tagged_component;
 455   tagged_component.tag = TAO_TAG_ENDPOINTS;
 456
 457   if (this->tagged_components_.get_component (tagged_component))
 458     {
 459       const CORBA::Octet *buf =
 460         tagged_component.component_data.get_buffer ();
 461
 462       TAO_InputCDR in_cdr (reinterpret_cast <const char*> (buf),
 463                            tagged_component.component_data.length ());
 464
 465       // Extract the Byte Order.
 466       CORBA::Boolean byte_order;
 467       if ((in_cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
 468         return -1;
 469       in_cdr.reset_byte_order (static_cast<int> (byte_order));
 470
 471       // Extract endpoints sequence.
 472       TAO::IIOPEndpointSequence endpoints;
 473
 474       if ((in_cdr >> endpoints) == 0)
 475         return -1;
 476
 477       // Get the priority of the first endpoint (head of the list.
 478       // It's other data is extracted as part of the standard profile
 479       // decoding.
 480       this->endpoint_.priority (endpoints[0].priority);
 481
 482       // Use information extracted from the tagged component to
 483       // populate the profile.  Skip the first endpoint, since it is
 484       // always extracted through standard profile body.  Also, begin
 485       // from the end of the sequence to preserve endpoint order,
 486       // since <add_endpoint> method reverses the order of endpoints
 487       // in the list.
 488       for (CORBA::ULong i = endpoints.length () - 1;
 489            i > 0;
 490            --i)
 491         {
 492           TAO_SHMIOP_Endpoint *endpoint = 0;
 493           ACE_NEW_RETURN (endpoint,
 494                           TAO_SHMIOP_Endpoint (endpoints[i].host,
 495                                                endpoints[i].port,
 496                                                endpoints[i].priority),
 497                           -1);
 498
 499           this->add_endpoint (endpoint);
 500         }
 501     }
 502
 503   return 0;
 504 }
 505
 506 TAO_END_VERSIONED_NAMESPACE_DECL
 507
 508 #endif /* TAO_HAS_SHMIOP && TAO_HAS_SHMIOP != 0 */