TAO/tao/Strategies/SCIOP_Profile.cpp

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