TAO_UIPMC_Profile Class Reference

This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network. More...

#include <UIPMC_Profile.h>

Inheritance diagram for TAO_UIPMC_Profile:

[legend]Collaboration diagram for TAO_UIPMC_Profile:

[legend]List of all members.

Public Member Functions
virtual char	object_key_delimiter (void) const
	TAO_UIPMC_Profile (TAO_ORB_Core *orb_core)
	TAO_UIPMC_Profile (const ACE_INET_Addr &addr, TAO_ORB_Core *orb_core)
	TAO_UIPMC_Profile (const CORBA::Octet class_d_address[4], CORBA::UShort port, TAO_ORB_Core *orb_core)
	Profile constructor. @ Vadym - deprecate this.
	TAO_UIPMC_Profile (const char *string, TAO_ORB_Core *orb_core)
	Create object using a string ior.
	~TAO_UIPMC_Profile (void)
	Destructor is to be called only through <_decr_refcnt>.
virtual int	decode (TAO_InputCDR &cdr)
	Template methods. Please see tao/Profile.h for documentation.
virtual void	parse_string (const char *string)
virtual char *	to_string (void)
virtual int	encode_endpoints (void)
virtual TAO_Endpoint *	endpoint (void)
virtual CORBA::ULong	endpoint_count (void) const
virtual CORBA::ULong	hash (CORBA::ULong max)
virtual IOP::TaggedProfile &	create_tagged_profile (void)
virtual void	request_target_specifier (TAO_Target_Specification &target_spec, TAO_Target_Specification::TAO_Target_Address r)
virtual int	supports_multicast (void) const
virtual void	addressing_mode (CORBA::Short addr_mode)
void	set_group_info (const char *domain_id, PortableGroup::ObjectGroupId group_id, PortableGroup::ObjectGroupRefVersion ref_version)
	Add the mandatory group component to this profile.
Static Public Member Functions
static const char *	prefix (void)
	Return the char string prefix.
static int	extract_group_component (const IOP::TaggedProfile &profile, PortableGroup::TagGroupTaggedComponent &group)
Static Public Attributes
static const char	object_key_delimiter_ = '/'
	The object key delimiter that UIPMC uses or expects.
Protected Member Functions
virtual int	decode_profile (TAO_InputCDR &cdr)
	Template methods, please see documentation in tao/Profile.h.
virtual int	decode_endpoints (void)
virtual void	parse_string_i (const char *)
virtual void	create_profile_body (TAO_OutputCDR &cdr) const
virtual CORBA::Boolean	do_is_equivalent (const TAO_Profile *other_profile)
virtual void	update_cached_group_component (void)
Protected Attributes
TAO_UIPMC_Endpoint	endpoint_
Private Attributes
IOP::TaggedProfile	tagged_profile_
	Cached version of our tagged profile.
ACE_CString	group_domain_id_
	Group Domain ID.
PortableGroup::ObjectGroupId	group_id_
	Our group ID within the group domain.
PortableGroup::ObjectGroupRefVersion	ref_version_
	The group reference's version.
bool	has_ref_version_
	A sign whether ref_version is really present.

---

Detailed Description

This class defines the protocol specific attributes required for locating ORBs over a TCP/IP network.

This class defines the UIPMC profile as specified in the CORBA specification.

Note:

This class inherits the ObjectKey from TAO_Profile which may not be needed at all! But lets punt on this for the timebeing.

Definition at line 51 of file UIPMC_Profile.h.

---

Constructor & Destructor Documentation

TAO_UIPMC_Profile::TAO_UIPMC_Profile

(

TAO_ORB_Core *

orb_core

)

Profile constructor, default. Used when the profile contents are not yet known or when it is being decoded from an IOR.

Definition at line 35 of file UIPMC_Profile.cpp.

References TAO_Profile::addressing_mode_, and default_addressing_mode_.

  : TAO_Profile (IOP::TAG_UIPMC,
                 orb_core,
                 TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)),
    endpoint_ (),
    tagged_profile_ ()
{
    addressing_mode_ = default_addressing_mode_;
}

TAO_UIPMC_Profile::TAO_UIPMC_Profile	(	const ACE_INET_Addr &	addr,
		TAO_ORB_Core *	orb_core
	)

Profile constructor, same as above except the object_key has already been marshaled.

Definition at line 45 of file UIPMC_Profile.cpp.

References TAO_Profile::addressing_mode_, and default_addressing_mode_.

  : TAO_Profile (IOP::TAG_UIPMC,
                 orb_core,
                 TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)),
    endpoint_ (addr),
    tagged_profile_ ()
{
    addressing_mode_ = default_addressing_mode_;
}

TAO_UIPMC_Profile::TAO_UIPMC_Profile	(	const CORBA::Octet	class_d_address[4],
		CORBA::UShort	port,
		TAO_ORB_Core *	orb_core
	)

Profile constructor. @ Vadym - deprecate this.

Definition at line 56 of file UIPMC_Profile.cpp.

References TAO_Profile::addressing_mode_, and default_addressing_mode_.

  : TAO_Profile (IOP::TAG_UIPMC,
                 orb_core,
                 TAO_GIOP_Message_Version (TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR)),
    endpoint_ (class_d_address, port),
    tagged_profile_ ()
{
    addressing_mode_ = default_addressing_mode_;
}

TAO_UIPMC_Profile::TAO_UIPMC_Profile	(	const char *	string,
		TAO_ORB_Core *	orb_core
	)

Create object using a string ior.

TAO_UIPMC_Profile::~TAO_UIPMC_Profile

(

void

)

Destructor is to be called only through <_decr_refcnt>.

Definition at line 85 of file UIPMC_Profile.cpp.

{
}

---

Member Function Documentation

void TAO_UIPMC_Profile::addressing_mode

(

CORBA::Short

addr_mode

)

[virtual]

Reimplemented from TAO_Profile.

Definition at line 813 of file UIPMC_Profile.cpp.

References CORBA::SystemException::_tao_minor_code(), TAO_Profile::addressing_mode_, CORBA::COMPLETED_NO, TAO_Target_Specification::Key_Addr, TAO_Target_Specification::Profile_Addr, TAO_Target_Specification::Reference_Addr, and TAO::VMCID.

{
  // ** See race condition note about addressing mode in Profile.h **
  switch (addr_mode)
    {
    case TAO_Target_Specification::Profile_Addr:
    case TAO_Target_Specification::Reference_Addr:
      this->addressing_mode_ = addr_mode;
      break;

    case TAO_Target_Specification::Key_Addr:
      // There is no object key, so it is not supported.

    default:
      throw CORBA::BAD_PARAM (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }
}

void TAO_UIPMC_Profile::create_profile_body

(

TAO_OutputCDR &

cdr

)

const [protected, virtual]

Implements TAO_Profile.

Definition at line 640 of file UIPMC_Profile.cpp.

References TAO_Tagged_Components::encode(), TAO_Profile::tagged_components(), TAO_ENCAP_BYTE_ORDER, ACE_OutputCDR::write_octet(), ACE_OutputCDR::write_string(), and ACE_OutputCDR::write_ushort().

{
  encap.write_octet (TAO_ENCAP_BYTE_ORDER);

  // The GIOP version
  // Note: Only GIOP 1.2 and above are supported currently for MIOP.
  encap.write_octet (this->version_.major);
  encap.write_octet (this->version_.minor);

  // Address.
  encap.write_string (this->endpoint_.host ());

  // Port number.
  encap.write_ushort (this->endpoint_.port ());

  // UIPMC is only supported by versions of GIOP that have tagged components,
  // so unconditionally encode the components.
  this->tagged_components ().encode (encap);
}

IOP::TaggedProfile & TAO_UIPMC_Profile::create_tagged_profile

(

void

)

[virtual]

Reimplemented from TAO_Profile.

Definition at line 600 of file UIPMC_Profile.cpp.

References ACE_OS::memcpy(), and tagged_profile_.

{
  // Check whether we have already created the TaggedProfile
  if (this->tagged_profile_.profile_data.length () == 0)
    {
      // As we have not created we will now create the TaggedProfile
      this->tagged_profile_.tag = IOP::TAG_UIPMC;

      // Create the encapsulation....
      TAO_OutputCDR encap;

      // Create the profile body
      this->create_profile_body (encap);

      CORBA::ULong length =
        static_cast<CORBA::ULong> (encap.total_length ());

#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
      // Place the message block in to the Sequence of Octets that we
      // have
      this->tagged_profile_.profile_data.replace (length,
                                                  encap.begin ());
#else
      this->tagged_profile_.profile_data.length (length);
      CORBA::Octet *buffer =
        this->tagged_profile_.profile_data.get_buffer ();
      for (const ACE_Message_Block *i = encap.begin ();
           i != encap.end ();
           i = i->next ())
        {
          ACE_OS::memcpy (buffer, i->rd_ptr (), i->length ());
          buffer += i->length ();
        }
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
    }

  return this->tagged_profile_;
}

int TAO_UIPMC_Profile::decode

(

TAO_InputCDR &

cdr

)

[virtual]

Template methods. Please see tao/Profile.h for documentation.

N.B. We have to override the TAO_Profile default decode because in UIPMC there is no object key marshalled and we do not implement a useable decode_endpoints

Reimplemented from TAO_Profile.

Definition at line 90 of file UIPMC_Profile.cpp.

References ACE_DEBUG, ACE_TEXT(), ACE_InputCDR::length(), LM_DEBUG, TAO_GIOP_Message_Version::major, TAO_GIOP_Message_Version::minor, ACE_InputCDR::read_octet(), TAO_debug_level, TAO_DEF_GIOP_MAJOR, TAO_DEF_GIOP_MINOR, and TAO_Profile::version_.

{
  // The following is a selective reproduction of TAO_Profile::decode

  CORBA::ULong encap_len = cdr.length ();

  // Read and verify major, minor versions, ignoring profiles
  // whose versions we don't understand.
  if (!(cdr.read_octet (this->version_.major)
        && this->version_.major == TAO_DEF_GIOP_MAJOR
        && cdr.read_octet (this->version_.minor)
        && this->version_.minor <= TAO_DEF_GIOP_MINOR))
    {
      if (TAO_debug_level > 0)
        {
          ACE_DEBUG ((LM_DEBUG,
                      ACE_TEXT ("TAO (%P|%t) - UIPMC_Profile::decode - v%d.%d\n"),
                      this->version_.major,
                      this->version_.minor));
        }

      return -1;
    }

  // Transport specific details
  if (this->decode_profile (cdr) < 0)
    {
      return -1;
    }

  // UIPMC profiles must have tagged components.
  if (this->tagged_components_.decode (cdr) == 0)
    {
      return -1;
    }

  if (cdr.length () != 0 && TAO_debug_level)
    {
      // If there is extra data in the profile we are supposed to
      // ignore it, but print a warning just in case...
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("%d bytes out of %d left after profile data\n"),
                  cdr.length (),
                  encap_len));
    }

  // We don't call ::decode_endpoints because it is implemented
  // as ACE_NOTSUP_RETURN (-1) for this profile

  return 1;
}

int TAO_UIPMC_Profile::decode_endpoints

(

void

)

[protected, virtual]

Implements TAO_Profile.

Definition at line 143 of file UIPMC_Profile.cpp.

References ACE_NOTSUP_RETURN.

{
  ACE_NOTSUP_RETURN (-1);
}

int TAO_UIPMC_Profile::decode_profile

(

TAO_InputCDR &

cdr

)

[protected, virtual]

Template methods, please see documentation in tao/Profile.h.

Implements TAO_Profile.

Definition at line 149 of file UIPMC_Profile.cpp.

References ACE_DEBUG, ACE_TEXT(), ACE_String_Base< CHAR >::c_str(), endpoint_, ACE_InputCDR::good_bit(), LM_DEBUG, TAO_UIPMC_Endpoint::object_addr(), ACE_InputCDR::read_string(), ACE_InputCDR::read_ushort(), and TAO_debug_level.

{
  CORBA::UShort port = 0;
  ACE_CString address;
  if (!(cdr.read_string (address)
        && cdr.read_ushort (port)))
    {
      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("TAO (%P|%t) - UIPMC_Profile::decode - ")
                    ACE_TEXT ("Couldn't unmarshal address and port!\n")));
      return -1;
    }

  if (cdr.good_bit ())
    {
      // If everything was successful, update the endpoint's address
      // and port with the new data.
      ACE_INET_Addr addr (port, address.c_str ());
      this->endpoint_.object_addr (addr);
      return 1;
    }

  return -1;
}

CORBA::Boolean TAO_UIPMC_Profile::do_is_equivalent

(

const TAO_Profile *

other_profile

)

[protected, virtual]

Implements TAO_Profile.

Definition at line 482 of file UIPMC_Profile.cpp.

References endpoint_, and TAO_UIPMC_Endpoint::is_equivalent().

{
  const TAO_UIPMC_Profile *op =
    dynamic_cast<const TAO_UIPMC_Profile *> (other_profile);

  if (op == 0)
    return 0;

  return this->endpoint_.is_equivalent (&op->endpoint_);
}

int TAO_UIPMC_Profile::encode_endpoints

(

void

)

[virtual]

Implements TAO_Profile.

Definition at line 512 of file UIPMC_Profile.cpp.

{
  return 1;
}

TAO_Endpoint * TAO_UIPMC_Profile::endpoint

(

void

)

[virtual]

Implements TAO_Profile.

Definition at line 506 of file UIPMC_Profile.cpp.

References endpoint_.

{
  return &this->endpoint_;
}

CORBA::ULong TAO_UIPMC_Profile::endpoint_count

(

void

)

const [virtual]

Implements TAO_Profile.

Definition at line 518 of file UIPMC_Profile.cpp.

{
  return 1;
}

int TAO_UIPMC_Profile::extract_group_component	(	const IOP::TaggedProfile &	profile,
		PortableGroup::TagGroupTaggedComponent &	group
	)			[static]

Definition at line 836 of file UIPMC_Profile.cpp.

References ACE_DEBUG, ACE_TEXT(), TAO_Tagged_Components::decode(), TAO_Tagged_Components::get_component(), LM_DEBUG, TAO_Profile::tagged_components(), and TAO_debug_level.

Referenced by PortableGroup_Request_Dispatcher::dispatch().

{
  // 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<const char*> (profile.profile_data.get_buffer ()),
                    profile.profile_data.length ());
//#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */

  // Extract the Byte Order.
  CORBA::Boolean byte_order;
  if ((cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
    return -1;
  cdr.reset_byte_order (static_cast<int> (byte_order));

  // Read and verify major, minor versions, ignoring UIPMC profiles
  // whose versions we don't understand.
  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) - UIPMC_Profile::extract_group_component - v%d.%d\n"),
                    major,
                    minor));
      }
    return -1;
  }

  // Decode the endpoint.
  ACE_CString address;
  CORBA::UShort port;

  if (!(cdr.read_string (address)
        && cdr.read_ushort (port)))
    {
      if (TAO_debug_level > 0)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("TAO (%P|%t) - UIPMC_Profile::extract_group_component - Couldn't unmarshal address and port!\n")));
      return -1;
    }

  TAO_Tagged_Components tagged_components;
  if (tagged_components.decode (cdr) == 0)
    return -1;

  IOP::TaggedComponent tagged_component;
  tagged_component.tag = IOP::TAG_GROUP;

  // Try to find it.
  if (tagged_components.get_component (tagged_component) == 0)
    return -1;

  // Found it.
  const CORBA::Octet *buf =
    tagged_component.component_data.get_buffer ();

  TAO_InputCDR in_cdr (reinterpret_cast<const char*> (buf),
                       tagged_component.component_data.length ());

  // Extract the Byte Order.
  if ((in_cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0)
    return -1;
  in_cdr.reset_byte_order (static_cast<int> (byte_order));

  if ((in_cdr >> group) == 0)
    return -1;

  return 0;
}

CORBA::ULong TAO_UIPMC_Profile::hash

(

CORBA::ULong

max

)

[virtual]

Implements TAO_Profile.

Definition at line 494 of file UIPMC_Profile.cpp.

References endpoint_, TAO_UIPMC_Endpoint::hash(), TAO_GIOP_Message_Version::minor, TAO_Profile::tag(), and TAO_Profile::version_.

{
  // Get the hashvalue for all endpoints.
  CORBA::ULong hashval = this->endpoint_.hash ();

  hashval += this->version_.minor;
  hashval += this->tag ();

  return hashval % max;
}

char TAO_UIPMC_Profile::object_key_delimiter

(

void

)

const [virtual]

Implements TAO_Profile.

Definition at line 30 of file UIPMC_Profile.cpp.

References object_key_delimiter_.

{
  return TAO_UIPMC_Profile::object_key_delimiter_;
}

void TAO_UIPMC_Profile::parse_string

(

const char *

string

)

[virtual]

Reimplemented from TAO_Profile.

Definition at line 176 of file UIPMC_Profile.cpp.

References parse_string_i().

{
  this->parse_string_i (string);
}

void TAO_UIPMC_Profile::parse_string_i

(

const char *

)

[protected, virtual]

Implements TAO_Profile.

Definition at line 182 of file UIPMC_Profile.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_ERROR, ACE_OS::ace_isdigit(), ACE_TEXT(), ACE_String_Base< CHAR >::c_str(), CORBA::COMPLETED_NO, endpoint_, ACE_INET_Addr::get_port_number(), has_ref_version_, ACE_String_Base< CHAR >::length(), LM_ERROR, TAO_GIOP_Message_Version::minor, TAO_UIPMC_Endpoint::object_addr(), set_group_info(), TAO_GIOP_Message_Version::set_version(), ACE_OS::strchr(), ACE_INET_Addr::string_to_addr(), ACE_OS::strlen(), ACE_OS::strspn(), ACE_OS::strtoul(), TAO_debug_level, TAO_DEF_MIOP_MAJOR, TAO_DEF_MIOP_MINOR, TAO_Profile::version(), TAO_Profile::version_, and TAO::VMCID.

Referenced by parse_string().

{
  // Remove the "N.n@" version prefix, if it exists, and verify the
  // version is one that we accept.

  // Check for MIOP version
  if (ACE_OS::ace_isdigit (string [0]) &&
      string[1] == '.' &&
      ACE_OS::ace_isdigit (string [2]) &&
      string[3] == '@')
    {
      if (string[0] != '1' ||
          string[2] != '0')
        {
          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              TAO::VMCID,
              EINVAL),
            CORBA::COMPLETED_NO);
        }

      string += 4;
      // Skip over the "N.n@"
    }

  // UIPMC profiles always use GIOP 1.2
  this->version_.set_version (1, 2);

  //
  // Parse the group_id.
  //

  // Parse the group component version.
  if (ACE_OS::ace_isdigit (string [0]) &&
      string[1] == '.' &&
      ACE_OS::ace_isdigit (string [2]) &&
      string[3] == '-')
    {
      CORBA::Char major;
      CORBA::Char minor;

      major = (char) (string [0] - '0');
      minor = (char) (string [2] - '0');

      // Verify that a supported version of MIOP is specified.
      if (major != TAO_DEF_MIOP_MAJOR ||
          minor >  TAO_DEF_MIOP_MINOR)
        {
          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              TAO::VMCID,
              EINVAL),
            CORBA::COMPLETED_NO);
        }

      // Skip over "N.n-"
      string += 4;
    }
  else
    {
      // The group component version is mandatory.
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Parse the group_domain_id.
  // The Domain ID is terminated with a '-'.

  // Look for the group domain delimitor.
  const char *pos = ACE_OS::strchr (string, '-');

  if (pos == 0)
    {
      // The group_domain_id is mandatory, so throw an
      // exception if it isn't found.
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Save the group_domain_id.
  ACE_CString group_domain_id (string, pos - string);

  // Parse the group_id.
  // The group_id is terminated with a '-' or a '/'.

  // Skip past the last '-'.
  string = pos + 1;
  pos = ACE_OS::strchr (string, '-');

  CORBA::Boolean parse_group_ref_version_flag = 0;

  if (pos != 0)
    {
      // String was terminated by a '-', so there's a group
      // reference version to be parsed.
      parse_group_ref_version_flag = 1;
    }
  else
    {
      // Look for a slash as the separator.
      pos = ACE_OS::strchr (string, '/');

      if (pos == 0)
        {
          // The Group ID is mandatory, so throw an exception.
          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              TAO::VMCID,
              EINVAL),
            CORBA::COMPLETED_NO);
        }
    }

  if (ACE_OS::strspn (string, "0123456789") !=
      static_cast<size_t> (pos - string))
    {
      // Throw an exception if it's not a proper number
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Get the group_id.
  ACE_CString str_group_id (string, pos - string);

  // Convert the domain_id into numerical form.
  // @@ group_id is actually 64 bits, but strtoul only can parse 32 bits.
  // @@ Need a 64 bit strtoul...
  PortableGroup::ObjectGroupId group_id =
    ACE_OS::strtoul (str_group_id.c_str (), 0, 10);

  this->has_ref_version_ = false;
  PortableGroup::ObjectGroupRefVersion ref_version = 0;
  if (parse_group_ref_version_flag)
    {
      // Try to find the group version.  It is terminated by a '/'.
      string = pos + 1;
      pos = ACE_OS::strchr (string, '/');
      if (pos == 0)
        {
          // The group version was expected but not found,
          // so throw an exception.
          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              TAO::VMCID,
              EINVAL),
            CORBA::COMPLETED_NO);
        }

      if (ACE_OS::strspn (string, "0123456789") !=
          static_cast<size_t> (pos - string))
        {
          // Throw an exception if it's not a proper number
          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              TAO::VMCID,
              EINVAL),
            CORBA::COMPLETED_NO);
        }

      ACE_CString str_group_ref_ver (string, pos - string);

      ref_version =
        ACE_OS::strtoul (str_group_ref_ver.c_str (), 0, 10);
      this->has_ref_version_ = true;
    }

  // Parse the group multicast address.
  // The multicast address is terminated by a ':'.
  string = pos + 1;
  pos = ACE_OS::strchr (string, ':');

  if (pos == 0)
    {
      // The multicast address is mandatory, so throw an exception,
      // since it wasn't found.
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  ACE_CString mcast_addr;

#if defined (ACE_HAS_IPV6)
  // Check if this is a (possibly) IPv6 supporting profile containing a
  // decimal IPv6 address representation.
  if ((this->version ().major > TAO_MIN_IPV6_IIOP_MAJOR ||
        this->version ().minor >= TAO_MIN_IPV6_IIOP_MINOR) &&
      string[0] == '[')
    {
      // In this case we have to find the end of the numeric address and
      // start looking for the port separator from there.
      pos = ACE_OS::strchr (string, ']');
      if (pos == 0)
        {
          // No valid IPv6 address specified.
          if (TAO_debug_level > 0)
            {
              ACE_ERROR ((LM_ERROR,
                          ACE_TEXT ("\nTAO (%P|%t) - UIPMC_Profile: ")
                          ACE_TEXT ("Invalid IPv6 decimal address specified.\n")));
            }

          throw CORBA::INV_OBJREF (
            CORBA::SystemException::_tao_minor_code (
              0,
              EINVAL),
            CORBA::COMPLETED_NO);
        }
      else
        {
          ++string;
          mcast_addr = ACE_CString (string, pos - string);
          string = pos + 2;
        }
    }
  else
    {
#endif /* ACE_HAS_IPV6 */
      mcast_addr = ACE_CString (string, pos - string);
      string = pos + 1;
#if defined (ACE_HAS_IPV6)
    }
#endif /* ACE_HAS_IPV6 */

  size_t mcast_addr_len = mcast_addr.length ();
  if (ACE_OS::strspn (mcast_addr.c_str (),
                      ".:0123456789ABCDEFabcdef") != mcast_addr_len)
    {
      // Throw an exception if it's not a proper IPv4/IPv6 address
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Parse the multicast port number.

  // First check that there's something left in the string.
  if (string[0] == '\0')
    {
      // The multicast port is mandatory, so throw an exception,
      // since it wasn't found.
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  // Port can have name thus letters and '-' are allowed.
  const char port_chars[] =
    "-0123456789ABCDEFGHIGKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
  size_t port_len = ACE_OS::strlen (string);
  if (ACE_OS::strspn (string, port_chars) != port_len)
    {
      // Throw an exception if it's not a proper port
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  ACE_INET_Addr ia;
  if (ia.string_to_addr (string) == -1)
    {
      throw CORBA::INV_OBJREF (
        CORBA::SystemException::_tao_minor_code (
          TAO::VMCID,
          EINVAL),
        CORBA::COMPLETED_NO);
    }

  u_short mcast_port = ia.get_port_number ();

  //
  // Finally, set all of the fields of the profile.
  //

  ACE_INET_Addr addr (mcast_port, mcast_addr.c_str ());
  this->endpoint_.object_addr (addr);

  this->set_group_info (group_domain_id.c_str (),
                        group_id,
                        ref_version);
}

const char * TAO_UIPMC_Profile::prefix

(

void

)

[static]

Return the char string prefix.

Definition at line 594 of file UIPMC_Profile.cpp.

References the_prefix.

{
  return ::the_prefix;
}

void TAO_UIPMC_Profile::request_target_specifier	(	TAO_Target_Specification &	target_spec,
		TAO_Target_Specification::TAO_Target_Address	r
	)			[virtual]

Definition at line 781 of file UIPMC_Profile.cpp.

References TAO_Target_Specification::Key_Addr, TAO_Target_Specification::Profile_Addr, TAO_Target_Specification::Reference_Addr, and TAO_Target_Specification::target_specifier().

{
  // Fill out the target specifier based on the required type.
  switch (required_type)
    {
    case TAO_Target_Specification::Profile_Addr:

      // Only using a profile as the target specifier is supported
      // at this time.  Object keys are strictly not supported since
      // UIPMC profiles do not have object keys.
      target_spec.target_specifier (
            this->create_tagged_profile ());
      break;

    case TAO_Target_Specification::Key_Addr:
    case TAO_Target_Specification::Reference_Addr:
    default:
      // Unsupported or unknown required type.  Throw an exception.
      throw CORBA::MARSHAL ();
    }
}

void TAO_UIPMC_Profile::set_group_info	(	const char *	domain_id,
		PortableGroup::ObjectGroupId	group_id,
		PortableGroup::ObjectGroupRefVersion	ref_version
	)

Add the mandatory group component to this profile.

Definition at line 718 of file UIPMC_Profile.cpp.

References group_domain_id_, group_id_, ref_version_, ACE_String_Base< CHAR >::set(), and update_cached_group_component().

Referenced by parse_string_i().

{
  // First, record the group information.
  this->group_domain_id_.set (domain_id);
  this->group_id_ = group_id;
  this->ref_version_ = ref_version;

  // Update the cached version of the group component.
  this->update_cached_group_component ();
}

int TAO_UIPMC_Profile::supports_multicast

(

void

)

const [virtual]

Reimplemented from TAO_Profile.

Definition at line 806 of file UIPMC_Profile.cpp.

{
  // Yes!  We support multicast!
  return 1;
}

char * TAO_UIPMC_Profile::to_string

(

void

)

[virtual]

Implements TAO_Profile.

Definition at line 524 of file UIPMC_Profile.cpp.

References endpoint_, group_domain_id_, group_id_, ACE_String_Base< CHAR >::length(), TAO_UIPMC_Endpoint::port(), ACE_OS::sprintf(), CORBA::string_alloc(), ACE_OS::strlen(), TAO_DEF_MIOP_MAJOR, TAO_DEF_MIOP_MINOR, and the_prefix.

{
  // corbaloc:miop:1.2@1.0-group_id-1-1/host:port

  size_t buflen = (8 /* "corbaloc" */ +
                   1 /* colon separator */ +
                   ACE_OS::strlen (::the_prefix) + /* "miop" */
                   1 /* colon separator */ +
                   1 /* major version */ +
                   1 /* decimal point */ +
                   1 /* minor version */ +
                   1 /* `@' character */ +
                   1 /* component major version */ +
                   1 /* decimal point */ +
                   1 /* component minor version */ +
                   1 /* `-' character */ +
                   this->group_domain_id_.length () + /* domain id */
                   1 /* `-' character */ +
                   20 /* group id */ +
                   1 /* `-' character */ +
                   10 /* group reference version */ +
                   1 /* `/' character */ +
                   39 /* IPv4/IPv6 address */ +
                   1 /* colon separator */ +
                   5 /* port number */);
#if defined (ACE_HAS_IPV6)
  if (this->endpoint_.object_addr ().get_type () == AF_INET6)
    buflen += 2; // room for '[' and ']'
#endif /* ACE_HAS_IPV6 */

  static const char digits [] = "0123456789";

  char * buf = CORBA::string_alloc (static_cast<CORBA::ULong> (buflen));

  ACE_OS::sprintf (buf,
                   "corbaloc:%s:%c.%c@%c.%c-%s-%llu",
                   ::the_prefix,
                   digits [this->version_.major],
                   digits [this->version_.minor],
                   digits [TAO_DEF_MIOP_MAJOR],
                   digits [TAO_DEF_MIOP_MINOR],
                   this->group_domain_id_.c_str (),
                   this->group_id_);

  if (this->has_ref_version_)
    {
      ACE_OS::sprintf (&buf[ACE_OS::strlen (buf)],
                       "-%lu",
                       this->ref_version_);
    }

#if defined (ACE_HAS_IPV6)
  if (this->endpoint_.object_addr ().get_type () == AF_INET6)
    {
      ACE_OS::sprintf (&buf[ACE_OS::strlen (buf)],
                       "/[%s]:%d",
                       this->endpoint_.host (),
                       this->endpoint_.port ());
    }
  else
#endif /* ACE_HAS_IPV6 */
  ACE_OS::sprintf (&buf[ACE_OS::strlen (buf)],
                   "/%s:%d",
                   this->endpoint_.host (),
                   this->endpoint_.port ());

  return buf;
}

void TAO_UIPMC_Profile::update_cached_group_component

(

void

)

[protected, virtual]

Definition at line 732 of file UIPMC_Profile.cpp.

References ACE_CDR_BYTE_ORDER, ACE_DEBUG, ACE_OutputCDR::begin(), ACE_Message_Block::cont(), group_id_, LM_DEBUG, ACE_OS::memcpy(), ref_version_, TAO_Tagged_Components::set_component(), CORBA::string_dup(), TAO_Profile::tagged_components_, TAO_DEF_MIOP_MAJOR, TAO_DEF_MIOP_MINOR, and ACE_OutputCDR::total_length().

Referenced by set_group_info().

{
  PortableGroup::TagGroupTaggedComponent group;

  // Encode the data structure.
  group.component_version.major = TAO_DEF_MIOP_MAJOR;
  group.component_version.minor = TAO_DEF_MIOP_MINOR;

  group.group_domain_id = CORBA::string_dup (this->group_domain_id_.c_str ());
  group.object_group_id = this->group_id_;
  group.object_group_ref_version = this->ref_version_;

  TAO_OutputCDR out_cdr;

  // Write the byte order.
  out_cdr << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);

  // Write the group information.
  if ((out_cdr << group) == 0)
    {
      ACE_DEBUG ((LM_DEBUG,
                  "Error marshaling group component!"));
      return;
    }

  size_t length = out_cdr.total_length ();

  IOP::TaggedComponent tagged_component;
  tagged_component.tag = IOP::TAG_GROUP;
  tagged_component.component_data.length (static_cast<CORBA::ULong> (length));
  CORBA::Octet *buf =
    tagged_component.component_data.get_buffer ();

  for (const ACE_Message_Block *iterator = out_cdr.begin ();
       iterator != 0;
       iterator = iterator->cont ())
    {
      size_t i_length = iterator->length ();
      ACE_OS::memcpy (buf, iterator->rd_ptr (), i_length);

      buf += i_length;
    }

  // Add component with encoded endpoint data to this profile's
  // TaggedComponents.
  this->tagged_components_.set_component (tagged_component);
}

---

Member Data Documentation

TAO_UIPMC_Endpoint TAO_UIPMC_Profile::endpoint_ [protected]

Head of this profile's list of endpoints. This endpoint is not dynamically allocated because a profile always contains at least one endpoint.

Currently, a profile contains more than one endpoint, i.e., list contains more than just the head, only when RTCORBA is enabled. However, in the near future, this will be used in nonRT mode as well, e.g., to support TAG_ALTERNATE_IIOP_ADDRESS feature. Addressing info of the default endpoint, i.e., head of the list, is transmitted using standard UIPMC ProfileBody components. See <encode_endpoints> method documentation above for how the rest of the endpoint list is transmitted.

Definition at line 135 of file UIPMC_Profile.h.

Referenced by decode_profile(), do_is_equivalent(), endpoint(), hash(), parse_string_i(), and to_string().

ACE_CString TAO_UIPMC_Profile::group_domain_id_ [private]

Group Domain ID.

Definition at line 143 of file UIPMC_Profile.h.

Referenced by set_group_info(), and to_string().

PortableGroup::ObjectGroupId TAO_UIPMC_Profile::group_id_ [private]

Our group ID within the group domain.

Definition at line 146 of file UIPMC_Profile.h.

Referenced by set_group_info(), to_string(), and update_cached_group_component().

bool TAO_UIPMC_Profile::has_ref_version_ [private]

A sign whether ref_version is really present.

Definition at line 152 of file UIPMC_Profile.h.

Referenced by parse_string_i().

TAO_BEGIN_VERSIONED_NAMESPACE_DECL const char TAO_UIPMC_Profile::object_key_delimiter_ = '/' [static]

The object key delimiter that UIPMC uses or expects.

Definition at line 55 of file UIPMC_Profile.h.

Referenced by object_key_delimiter(), and TAO_UIPMC_Connector::object_key_delimiter().

PortableGroup::ObjectGroupRefVersion TAO_UIPMC_Profile::ref_version_ [private]

The group reference's version.

Definition at line 149 of file UIPMC_Profile.h.

Referenced by set_group_info(), and update_cached_group_component().

IOP::TaggedProfile TAO_UIPMC_Profile::tagged_profile_ [private]

Cached version of our tagged profile.

Reimplemented from TAO_Profile.

Definition at line 140 of file UIPMC_Profile.h.

Referenced by create_tagged_profile().

---

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

• UIPMC_Profile.h
• UIPMC_Profile.cpp

---