int
TAO_Stub::get_profile_ior_info (TAO_MProfile &profiles, IOP::IOR *&ior_info)
{
ACE_NEW_THROW_EX (ior_info,
IOP::IOR (),
CORBA::NO_MEMORY ());
// Get the number of elements
CORBA::ULong const count = profiles.profile_count ();
// Set the number of elements in the sequence of tagged_profile
ior_info->profiles.length (count);
// Call the create_tagged_profile one every member of the
// profile and make the sequence
for (CORBA::ULong index = 0; index < count; ++index)
{
TAO_Profile *prof = profiles.get_profile (index);
IOP::TaggedProfile *tp = prof->create_tagged_profile ();
if (tp == 0)
throw ::CORBA::NO_MEMORY ();
ior_info->profiles[index] = *tp;
}
return 0;
}
int
TAO_Server_Protocol_Acceptor_Filter::encode_endpoints (TAO_MProfile &mprofile)
{
// Encode endpoints.
for (CORBA::ULong i = 0; i < mprofile.profile_count (); ++i)
{
TAO_Profile *profile = mprofile.get_profile (i);
if (profile->encode_endpoints () == -1)
return -1;
}
return 0;
}
TAO_Profile *
TAO_DIOP_Connector::create_profile (TAO_InputCDR& cdr)
{
TAO_Profile *pfile = 0;
ACE_NEW_RETURN (pfile,
TAO_DIOP_Profile (this->orb_core ()),
0);
if (pfile->decode (cdr) == -1)
{
pfile->_decr_refcnt ();
pfile = 0;
}
return pfile;
}
void
Profile_Transport_Resolver::profile (TAO_Profile *p)
{
// Dont do anything if the incoming profile is null
if (p)
{
// @note This is just a workaround for a more serious problem
// with profile management. This would cover some potential
// issues that Ossama is working on. Ossama, please remove
// them when you are done.
TAO_Profile *tmp = this->profile_;
(void) p->_incr_refcnt ();
this->profile_ = p;
if (tmp)
{
(void) tmp->_decr_refcnt ();
}
}
}
bool
TAO_Acceptor_Registry::is_collocated (const TAO_MProfile &mprofile)
{
TAO_AcceptorSetIterator const end = this->end ();
CORBA::ULong const count = mprofile.profile_count ();
// If at least one endpoint in one of the profiles matches one of
// the acceptors, we are collocated.
for (TAO_AcceptorSetIterator i = this->begin (); i != end; ++i)
{
for (TAO_PHandle j = 0; j != count; ++j)
{
const TAO_Profile *profile = mprofile.get_profile (j);
// @@ We need to invoke a nonconst <endpoint> method on
// <profile>. The content of profile/endpoint will not
// be modified.
TAO_Profile *pf = const_cast<TAO_Profile *> (profile);
// Check all endpoints for address equality.
if ((*i)->tag () == pf->tag ())
{
// @note This can be a potentially expensive (O(n^2))
// operation if the below is_collocated() call
// also executes a loop.
for (TAO_Endpoint *endp = pf->endpoint ();
endp != 0;
endp = endp->next ())
{
if ((*i)->is_collocated (endp))
{
return true;
}
}
}
}
}
return false;
}
int
TAO::SSLIOP::Acceptor::create_shared_profile (const TAO::ObjectKey &object_key,
TAO_MProfile &mprofile,
CORBA::Short priority)
{
size_t index = 0;
TAO_Profile *pfile = 0;
TAO_SSLIOP_Profile *ssliop_profile = 0;
// First see if <mprofile> already contains a SSLIOP profile.
for (TAO_PHandle i = 0; i != mprofile.profile_count (); ++i)
{
pfile = mprofile.get_profile (i);
if (pfile->tag () == IOP::TAG_INTERNET_IOP)
{
ssliop_profile = dynamic_cast<TAO_SSLIOP_Profile *> (pfile);
if (ssliop_profile == 0)
return -1;
break;
}
}
// If <mprofile> doesn't contain SSLIOP_Profile, we need to create
// one.
if (ssliop_profile == 0)
{
// @@ We need to create an SSLIOP::SSL component for the object
// we're creating an MProfile for. This will allow us to
// properly embed secure invocation policies in the generated
// IOR, i.e. secure invocation policies on a per-object
// basis, rather than on a per-endpoint basis. If no secure
// invocation policies have been set then we should use the
// below default SSLIOP::SSL component.
ACE_NEW_RETURN (ssliop_profile,
TAO_SSLIOP_Profile (this->hosts_[0],
this->addrs_[0].get_port_number (),
object_key,
this->addrs_[0],
this->version_,
this->orb_core_,
&(this->ssl_component_)),
-1);
TAO_SSLIOP_Endpoint * const ssliop_endp =
dynamic_cast<TAO_SSLIOP_Endpoint *> (ssliop_profile->endpoint ());
if (!ssliop_endp)
return -1;
ssliop_endp->priority (priority);
ssliop_endp->iiop_endpoint ()->priority (priority);
if (mprofile.give_profile (ssliop_profile) == -1)
{
ssliop_profile->_decr_refcnt ();
ssliop_profile = 0;
return -1;
}
if (this->orb_core_->orb_params ()->std_profile_components () != 0)
{
ssliop_profile->tagged_components ().set_orb_type (TAO_ORB_TYPE);
TAO_Codeset_Manager *csm = this->orb_core_->codeset_manager();
if (csm)
csm->set_codeset(ssliop_profile->tagged_components());
IOP::TaggedComponent component;
component.tag = ::SSLIOP::TAG_SSL_SEC_TRANS;
// @@???? Check this code, only intended as guideline...
TAO_OutputCDR cdr;
cdr << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER);
// @@ We need to create an SSLIOP::SSL component for the
// object we're creating an MProfile for. This will
// allow us to properly embed secure invocation policies
// in the generated IOR, i.e. secure invocation policies
// on a per-object basis, rather than on a per-endpoint
// basis. If no secure invocation policies have been set
// then we should use the below default SSLIOP::SSL
// component.
cdr << this->ssl_component_;
// TAO extension, replace the contents of the octet sequence with
// the CDR stream
CORBA::ULong length = cdr.total_length ();
component.component_data.length (length);
CORBA::Octet *buf = component.component_data.get_buffer ();
for (const ACE_Message_Block *i = cdr.begin ();
i != 0;
i = i->cont ())
{
ACE_OS::memcpy (buf, i->rd_ptr (), i->length ());
buf += i->length ();
}
ssliop_profile->tagged_components ().set_component (component);
}
index = 1;
}
// Add any remaining endpoints to the SSLIOP_Profile.
for (;
index < this->endpoint_count_;
++index)
{
TAO_SSLIOP_Endpoint *ssl_endp = 0;
TAO_IIOP_Endpoint *iiop_endp = 0;
ACE_NEW_RETURN (iiop_endp,
TAO_IIOP_Endpoint (this->hosts_[index],
this->addrs_[index].get_port_number (),
this->addrs_[index]),
-1);
iiop_endp->priority (priority);
ACE_NEW_RETURN (ssl_endp,
TAO_SSLIOP_Endpoint (&(this->ssl_component_),
iiop_endp),
-1);
ssl_endp->priority (priority);
ssliop_profile->add_endpoint (ssl_endp);
}
return 0;
}
int
TAO_Connector::make_mprofile (const char *string, TAO_MProfile &mprofile)
{
// This method utilizes the "Template Method" design pattern to
// parse the given URL style IOR for the protocol being used
// and create an mprofile from it.
//
// The methods that must be defined by all Connector sub-classes are:
// make_profile
// check_prefix
// Check for a valid string
if (!string || !*string)
{
throw ::CORBA::INV_OBJREF (
CORBA::SystemException::_tao_minor_code (
0,
EINVAL),
CORBA::COMPLETED_NO);
}
// Check for the proper prefix in the IOR. If the proper prefix isn't
// in the IOR then it is not an IOR we can use.
if (this->check_prefix (string) != 0)
{
return 1;
// Failure: not the correct IOR for this protocol.
// DO NOT throw an exception here since the Connector_Registry
// should be allowed the opportunity to continue looking for
// an appropriate connector.
}
if (TAO_debug_level > 0)
{
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - TAO_Connector::make_mprofile ")
ACE_TEXT ("<%C>\n"),
string));
}
ACE_CString ior;
ior.set (string, ACE_OS::strlen (string), 1);
// Find out where the protocol ends
ACE_CString::size_type ior_index = ior.find ("://");
if (ior_index == ACE_CString::npos)
{
throw ::CORBA::INV_OBJREF ();
// No colon ':' in the IOR!
}
else
{
ior_index += 3;
// Add the length of the colon and the two forward slashes `://'
// to the IOR string index (i.e. 3)
}
// Find the object key
const ACE_CString::size_type objkey_index =
ior.find (this->object_key_delimiter (), ior_index);
if (objkey_index == 0 || objkey_index == ACE_CString::npos)
{
throw ::CORBA::INV_OBJREF ();
// Failure: No endpoints specified or no object key specified.
}
const char endpoint_delimiter = ',';
// The delimiter used to separate individual addresses.
// Count the number of endpoints in the IOR. This will be the number
// of entries in the MProfile.
CORBA::ULong profile_count = 1;
// Number of endpoints in the IOR (initialized to 1).
// Only check for endpoints after the protocol specification and
// before the object key.
for (ACE_CString::size_type i = ior_index; i < objkey_index; ++i)
{
if (ior[i] == endpoint_delimiter)
++profile_count;
}
// Tell the MProfile object how many Profiles it should hold.
// MProfile::set(size) returns the number profiles it can hold.
if (mprofile.set (profile_count) != static_cast<int> (profile_count))
{
throw ::CORBA::INV_OBJREF (
CORBA::SystemException::_tao_minor_code (
TAO_MPROFILE_CREATION_ERROR,
0),
CORBA::COMPLETED_NO);
// Error while setting the MProfile size!
}
// The idea behind the following loop is to split the IOR into several
// strings that can be parsed by each profile.
// For example,
// `1.3@moo,shu,1.1@chicken/arf'
// will be parsed into:
// `1.3@moo/arf'
// `shu/arf'
// `1.1@chicken/arf'
ACE_CString::size_type begin = 0;
ACE_CString::size_type end = ior_index - 1;
// Initialize the end of the endpoint index
for (CORBA::ULong j = 0; j < profile_count; ++j)
{
begin = end + 1;
if (j < profile_count - 1)
{
end = ior.find (endpoint_delimiter, begin);
}
else
{
end = objkey_index; // Handle last endpoint differently
}
if (end < ior.length () && end != ior.npos)
{
ACE_CString endpoint = ior.substring (begin, end - begin);
// Add the object key to the string.
endpoint += ior.substring (objkey_index);
// The endpoint should now be of the form:
// `N.n@endpoint/object_key'
// or
// `endpoint/object_key'
TAO_Profile *profile =
this->make_profile ();
// Failure: Problem during profile creation
// Initialize a Profile using the individual endpoint
// string.
// @@ Not exception safe! We need a TAO_Profile_var!
profile->parse_string (endpoint.c_str ()
);
// Give up ownership of the profile.
if (mprofile.give_profile (profile) == -1)
{
profile->_decr_refcnt ();
throw ::CORBA::INV_OBJREF (
CORBA::SystemException::_tao_minor_code (
TAO_MPROFILE_CREATION_ERROR,
0),
CORBA::COMPLETED_NO);
// Failure presumably only occurs when MProfile is full!
// This should never happen.
}
}
else
{
throw ::CORBA::INV_OBJREF ();
// Unable to separate endpoints
}
}
return 0; // Success
}
void
TAO_RT_Invocation_Endpoint_Selector::select_endpoint_based_on_client_protocol_policy (
TAO::Profile_Transport_Resolver &r,
RTCORBA::ClientProtocolPolicy_ptr client_protocol_policy,
RTCORBA::ProtocolList &client_protocols,
ACE_Time_Value *val)
{
CORBA::Boolean valid_profile_found = false;
// Even though cycling through all the protocols is the correct
// things to do to find a match, starting from the start of the
// profile list is not. In addition, this code is also ignoring the
// forwarded reference (if it exists). This behavior is caused by
// problems with the profile management in TAO which are documented
// in bugzilla bugs 1237, 1238, and 1239. Once the above problems
// are fixed, this behavior should be fixed to do the right thing.
for (CORBA::ULong protocol_index = 0;
protocol_index < client_protocols.length ();
++protocol_index)
{
// Find the profiles that match the current protocol.
TAO_Profile *profile = 0;
TAO_MProfile &mprofile = (r.stub ()->forward_profiles() == 0) ?
r.stub ()->base_profiles () : *r.stub ()->forward_profiles();
for (TAO_PHandle i = 0;
i < mprofile.profile_count ();
++i)
{
profile = mprofile.get_profile (i);
if (profile->tag () == client_protocols[protocol_index].protocol_type)
{
valid_profile_found = true;
r.profile (profile);
if (this->endpoint_from_profile (r, val) == 1)
return;
// @@ Else we should check for potential forwarding here.
}
}
}
// We have tried all the profiles specified in the client protocol
// policy with no success. Throw exception.
if (!valid_profile_found)
{
CORBA::PolicyList *p = r.inconsistent_policies ();
if (p)
{
p->length (1);
(*p)[0u] = CORBA::Policy::_duplicate (client_protocol_policy);
}
throw ::CORBA::INV_POLICY ();
}
// If we get here, we completely failed to find an endpoint
// that we know how to use. We used to throw an exception
// but that would prevent any request interception points
// being called. They may know how to fix the problem so
// we wait to throw the exception in
// Synch_Twoway_Invocation::remote_twoway and
// Synch_Oneway_Invocation::remote_oneway instead.
}