TAO_BEGIN_VERSIONED_NAMESPACE_DECL
bool
TAO::TypeCode::Union<char const *,
CORBA::TypeCode_ptr const *,
TAO::TypeCode::Case<char const *,
CORBA::TypeCode_ptr const *> const * const *,
TAO::Null_RefCount_Policy>::tao_marshal (
TAO_OutputCDR & cdr,
CORBA::ULong offset) const
{
// A tk_union TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
// Account for the encoded CDR encapsulation length and byte order.
//
// Aligning on an octet since the next value after the CDR
// encapsulation length will always be the byte order octet/boolean
// in this case.
offset = ACE_Utils::truncate_cast<CORBA::ULong> (
ACE_align_binary (offset + 4,
ACE_CDR::OCTET_ALIGN));
bool const success =
(enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.id (), 0))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.name (), 0))
&& marshal (enc,
Traits<char const *>::get_typecode (this->discriminant_type_),
ACE_Utils::truncate_cast<CORBA::ULong> (
offset + enc.total_length ()))
&& (enc << this->default_index_)
&& (enc << this->ncases_);
if (!success)
{
return false;
}
// Note that we handle the default case below, too.
for (CORBA::ULong i = 0; i < this->ncases_; ++i)
{
case_type const & c = *this->cases_[i];
if (!c.marshal (enc, offset))
{
return false;
}
}
return
cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
bool
TAO::TypeCode::Alias<StringType,
TypeCodeType,
RefCountPolicy>::tao_marshal (TAO_OutputCDR & cdr,
CORBA::ULong offset) const
{
// A tk_alias TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
// Account for the encoded CDR encapsulation length and byte order.
//
// Aligning on an octet since the next value after the CDR
// encapsulation length will always be the byte order octet/boolean
// in this case.
offset = ACE_Utils::truncate_cast<CORBA::ULong> (
ACE_align_binary (offset + 4,
ACE_CDR::OCTET_ALIGN));
return
enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
&& enc << TAO_OutputCDR::from_string (this->attributes_.id (), 0)
&& enc << TAO_OutputCDR::from_string (this->attributes_.name (), 0)
&& marshal (enc,
Traits<StringType>::get_typecode (this->content_type_),
ACE_Utils::truncate_cast<CORBA::ULong> (
offset + enc.total_length ()))
&& cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
void Replication_Service::replicate_request(const FtRtecEventChannelAdmin::Operation& update,
RollbackOperation rollback)
{
TAO_OutputCDR cdr;
cdr << update;
ACE_Message_Block mb;
ACE_CDR::consolidate(&mb, cdr.begin());
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
FTRT::State state(mb.length(), &mb);
#else
// If the form of the constructor is not available, we will need
// to do the copy manually. First, set the octet sequence length.
FTRT::State state;
CORBA::ULong length = mb.length ();
state.length (length);
// Now copy over each byte.
char* base = mb.data_block ()->base ();
for(CORBA::ULong i = 0; i < length; i++)
{
state[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
replication_strategy->replicate_request(
state,
rollback,
update.object_id);
}
bool operator ()( DeviceProxy& device, CORBA::ULong cmd, CORBA::ULong cls ) const {
TAO_OutputCDR cdr;
device.prepare_data( cdr ) << cmd;
cdr << cls;
cdr << d_;
return device.sendto( cdr.begin() );
}
bool
TAO::TypeCode::Value<StringType,
TypeCodeType,
FieldArrayType,
RefCountPolicy>::tao_marshal (
TAO_OutputCDR & cdr,
CORBA::ULong offset) const
{
// A tk_value TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
// Account for the encoded CDR encapsulation length and byte order.
//
// Aligning on an octet since the next value after the CDR
// encapsulation length will always be the byte order octet/boolean
// in this case.
offset = ACE_align_binary (offset + 4,
ACE_CDR::OCTET_ALIGN);
bool const success =
(enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.id (), 0))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.name (), 0))
&& (enc << this->type_modifier_)
&& marshal (enc,
Traits<StringType>::get_typecode (this->concrete_base_),
offset + enc.total_length ())
&& (enc << this->nfields_);
if (!success)
return false;
Value_Field<StringType, TypeCodeType> const * const begin =
&this->fields_[0];
Value_Field<StringType, TypeCodeType> const * const end =
begin + this->nfields_;
for (Value_Field<StringType, TypeCodeType> const * i = begin; i != end; ++i)
{
Value_Field<StringType, TypeCodeType> const & field = *i;
if (!(enc << Traits<StringType>::get_string (field.name))
|| !marshal (enc,
Traits<StringType>::get_typecode (field.type),
offset + enc.total_length ())
|| !(enc << field.visibility))
return false;
}
return
cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
void
Task::dispatch_command( ACE_Message_Block * mblk )
{
CORBA::ULong cmd = marshal<CORBA::ULong>::get( mblk ); //SESSION_INITIALIZE, MB_COMMAND );
acewrapper::scoped_mutex_t<> lock( mutex_ );
for ( map_type::iterator it = device_proxies_.begin(); it != device_proxies_.end(); ++it ) {
TAO_OutputCDR cdr;
it->second->prepare_data( cdr ) << cmd;
const ACE_Message_Block * mb = cdr.begin();
logger log;
log.dump( mb->length(), mb->rd_ptr() );
log << " sendto: " << it->first;
it->second->sendto( cdr.begin() );
}
}
void
Logging::commit_to_task()
{
// Broker::EventLog, that is not EventLog
if ( msg.get().format.in() && *msg.get().format.in() != 0 ) {
TAO_OutputCDR cdr;
cdr << msg.get();
ACE_Message_Block * mb = cdr.begin()->duplicate();
mb->msg_type( constants::MB_EVENTLOG );
iTask::instance()->putq( mb );
}
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
bool
TAO::TypeCode::Enum<char const *,
char const * const *,
TAO::Null_RefCount_Policy>::tao_marshal (
TAO_OutputCDR & cdr,
CORBA::ULong) const
{
// A tk_enum TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
bool const success =
(enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.id (), 0))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.name (), 0))
&& (enc << this->nenumerators_);
if (!success)
return false;
char const * const * const begin = &this->enumerators_[0];
char const * const * const end = begin + this->nenumerators_;
for (char const * const * i = begin; i != end; ++i)
{
char const * const & enumerator = *i;
if (!(enc << TAO_OutputCDR::from_string (
Traits<char const *>::get_string (enumerator), 0)))
return false;
}
return
cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
int
Task::handle_timeout( const ACE_Time_Value& tv, const void * )
{
do {
ACE_Message_Block * mb = new ACE_Message_Block( sizeof( tv ) );
*reinterpret_cast< ACE_Time_Value *>(mb->wr_ptr()) = tv;
mb->wr_ptr( sizeof(tv) );
putq( mb );
} while(0);
do {
TAO_OutputCDR cdr;
cdr << constants::SESSION_QUERY_DEVICE;
cdr << TOFConstants::ClassID_AnalyzerDeviceData;
cdr << TOFConstants::ClassID_MSMethod;
cdr << GlobalConstants::EOR;
ACE_Message_Block * mb = cdr.begin()->duplicate();
mb->msg_type( constants::MB_QUERY_DEVICE );
this->putq( mb );
} while(0);
return 0;
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
bool
TAO::TypeCode::Objref<char const *, TAO::Null_RefCount_Policy>::tao_marshal (
TAO_OutputCDR & cdr,
CORBA::ULong) const
{
// A tk_objref TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
return
enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER)
&& enc << TAO_OutputCDR::from_string (this->attributes_.id (), 0)
&& enc << TAO_OutputCDR::from_string (this->attributes_.name (), 0)
&& cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
int
TAO_DIOP_Transport::send_message (TAO_OutputCDR &stream,
TAO_Stub *stub,
TAO_ServerRequest *request,
TAO_Message_Semantics message_semantics,
ACE_Time_Value *max_wait_time)
{
// Format the message in the stream first
if (this->messaging_object ()->format_message (stream, stub, request) != 0)
{
return -1;
}
// Strictly speaking, should not need to loop here because the
// socket never gets set to a nonblocking mode ... some Linux
// versions seem to need it though. Leaving it costs little.
// This guarantees to send all data (bytes) or return an error.
ssize_t const n = this->send_message_shared (stub,
message_semantics,
stream.begin (),
max_wait_time);
if (n == -1)
{
if (TAO_debug_level)
TAOLIB_DEBUG ((LM_DEBUG,
ACE_TEXT ("TAO (%P|%t) - DIOP_Transport::send_message, ")
ACE_TEXT ("closing transport %d after fault %p\n"),
this->id (),
ACE_TEXT ("send_message ()\n")));
return -1;
}
return 1;
}
void
TAO_ECG_CDR_Message_Sender::send_message (const TAO_OutputCDR &cdr,
const ACE_INET_Addr &addr)
{
if (this->endpoint_rptr_.get () == 0)
{
ORBSVCS_ERROR ((LM_ERROR, "Attempt to invoke send_message() "
"on non-initialized sender object.\n"));
throw CORBA::INTERNAL ();
}
CORBA::ULong max_fragment_payload = this->mtu () -
TAO_ECG_CDR_Message_Sender::ECG_HEADER_SIZE;
// ACE_ASSERT (max_fragment_payload != 0);
#if defined (ACE_HAS_BROKEN_DGRAM_SENDV)
const int TAO_WRITEV_MAX = ACE_IOV_MAX - 1;
#else
const int TAO_WRITEV_MAX = ACE_IOV_MAX;
#endif /* ACE_HAS_BROKEN_DGRAM_SENDV */
iovec iov[TAO_WRITEV_MAX];
CORBA::ULong total_length;
CORBA::ULong fragment_count =
this->compute_fragment_count (cdr.begin (),
cdr.end (),
TAO_WRITEV_MAX,
max_fragment_payload,
total_length);
CORBA::ULong request_id = this->endpoint_rptr_->next_request_id ();
// Reserve the first iovec for the header...
int iovcnt = 1;
CORBA::ULong fragment_id = 0;
CORBA::ULong fragment_offset = 0;
CORBA::ULong fragment_size = 0;
for (const ACE_Message_Block* b = cdr.begin ();
b != cdr.end ();
b = b->cont ())
{
CORBA::ULong l = b->length ();
char* rd_ptr = b->rd_ptr ();
iov[iovcnt].iov_base = rd_ptr;
iov[iovcnt].iov_len = l;
fragment_size += l;
++iovcnt;
while (fragment_size > max_fragment_payload)
{
// This fragment is full, we have to send it...
// First adjust the last iov entry:
CORBA::ULong last_mb_length =
max_fragment_payload - (fragment_size - l);
iov[iovcnt - 1].iov_len = last_mb_length;
this->send_fragment (addr,
request_id,
total_length,
max_fragment_payload,
fragment_offset,
fragment_id,
fragment_count,
iov,
iovcnt);
++fragment_id;
fragment_offset += max_fragment_payload;
// Reset, but don't forget that the last Message_Block
// may need to be sent in multiple fragments..
l -= last_mb_length;
rd_ptr += last_mb_length;
iov[1].iov_base = rd_ptr;
iov[1].iov_len = l;
fragment_size = l;
iovcnt = 2;
}
if (fragment_size == max_fragment_payload)
{
// We filled a fragment, but this time it was filled
// exactly, the treatment is a little different from the
// loop above...
this->send_fragment (addr,
request_id,
total_length,
max_fragment_payload,
fragment_offset,
fragment_id,
fragment_count,
iov,
iovcnt);
++fragment_id;
fragment_offset += max_fragment_payload;
iovcnt = 1;
fragment_size = 0;
}
if (iovcnt == TAO_WRITEV_MAX)
{
// Now we ran out of space in the iovec, we must send a
// fragment to work around that....
this->send_fragment (addr,
request_id,
total_length,
fragment_size,
fragment_offset,
fragment_id,
fragment_count,
iov,
iovcnt);
++fragment_id;
fragment_offset += fragment_size;
iovcnt = 1;
fragment_size = 0;
}
}
// There is something left in the iovvec that we must send
// also...
if (iovcnt != 1)
{
// Now we ran out of space in the iovec, we must send a
// fragment to work around that....
this->send_fragment (addr,
request_id,
total_length,
fragment_size,
fragment_offset,
fragment_id,
fragment_count,
iov,
iovcnt);
++fragment_id;
fragment_offset += fragment_size;
// reset, not needed here...
// iovcnt = 1;
// fragment_size = 0;
}
// ACE_ASSERT (total_length == fragment_offset);
// ACE_ASSERT (fragment_id == fragment_count);
}
void
TAO_ECG_CDR_Message_Sender::send_fragment (const ACE_INET_Addr &addr,
CORBA::ULong request_id,
CORBA::ULong request_size,
CORBA::ULong fragment_size,
CORBA::ULong fragment_offset,
CORBA::ULong fragment_id,
CORBA::ULong fragment_count,
iovec iov[],
int iovcnt)
{
CORBA::ULong header[TAO_ECG_CDR_Message_Sender::ECG_HEADER_SIZE
/ sizeof(CORBA::ULong)
+ ACE_CDR::MAX_ALIGNMENT];
char* buf = reinterpret_cast<char*> (header);
TAO_OutputCDR cdr (buf, sizeof(header));
cdr.write_boolean (TAO_ENCAP_BYTE_ORDER);
// Insert some known values in the padding bytes, so we can smoke
// test the message on the receiving end.
cdr.write_octet ('A'); cdr.write_octet ('B'); cdr.write_octet ('C');
cdr.write_ulong (request_id);
cdr.write_ulong (request_size);
cdr.write_ulong (fragment_size);
cdr.write_ulong (fragment_offset);
cdr.write_ulong (fragment_id);
cdr.write_ulong (fragment_count);
CORBA::Octet padding[4];
// MRH
if (checksum_)
{
// Compute CRC
iov[0].iov_base = cdr.begin ()->rd_ptr ();
iov[0].iov_len = cdr.begin ()->length ();
unsigned int crc = 0;
unsigned char *crc_parts = (unsigned char *)(&crc);
if (iovcnt > 1)
{
crc = ACE::crc32 (iov, iovcnt);
crc = ACE_HTONL (crc);
}
for (int cnt=0; cnt<4; ++cnt)
{
padding[cnt] = crc_parts[cnt];
}
}
else
{
for (int cnt=0; cnt<4; ++cnt)
{
padding[cnt] = 0;
}
}
//End MRH
cdr.write_octet_array (padding, 4);
iov[0].iov_base = cdr.begin ()->rd_ptr ();
iov[0].iov_len = cdr.begin ()->length ();
ssize_t n = this->dgram ().send (iov,
iovcnt,
addr);
size_t expected_n = 0;
for (int i = 0; i < iovcnt; ++i)
expected_n += iov[i].iov_len;
if (n > 0 && size_t(n) != expected_n)
{
ORBSVCS_ERROR ((LM_ERROR, ("Sent only %d out of %d bytes "
"for mcast fragment.\n"),
n,
expected_n));
}
if (n == -1)
{
if (errno == EWOULDBLOCK)
{
ORBSVCS_ERROR ((LM_ERROR, "Send of mcast fragment failed (%m).\n"));
// @@ TODO Use a Event Channel specific exception
throw CORBA::COMM_FAILURE ();
}
else
{
ORBSVCS_DEBUG ((LM_WARNING, "Send of mcast fragment blocked (%m).\n"));
}
}
else if (n == 0)
{
ORBSVCS_DEBUG ((LM_WARNING, "EOF on send of mcast fragment (%m).\n"));
}
}
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::SSLIOP::Acceptor::create_new_profile (const TAO::ObjectKey &object_key,
TAO_MProfile &mprofile,
CORBA::Short priority)
{
// Adding this->endpoint_count_ to the TAO_MProfile.
const int count = mprofile.profile_count ();
if ((mprofile.size () - count) < this->endpoint_count_
&& mprofile.grow (count + this->endpoint_count_) == -1)
return -1;
// Create a profile for each acceptor endpoint.
for (size_t i = 0; i < this->endpoint_count_; ++i)
{
TAO_SSLIOP_Profile *pfile = 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 (pfile,
TAO_SSLIOP_Profile (this->hosts_[i],
this->addrs_[i].get_port_number (),
object_key,
this->addrs_[i],
this->version_,
this->orb_core_,
&(this->ssl_component_)),
-1);
pfile->endpoint ()->priority (priority);
if (mprofile.give_profile (pfile) == -1)
{
pfile->_decr_refcnt ();
pfile = 0;
return -1;
}
if (this->orb_core_->orb_params ()->std_profile_components () == 0)
continue;
pfile->tagged_components ().set_orb_type (TAO_ORB_TYPE);
TAO_Codeset_Manager *csm = this->orb_core_->codeset_manager();
if (csm)
csm->set_codeset (pfile->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
const 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 ();
}
pfile->tagged_components ().set_component (component);
}
return 0;
}
int ACE_TMAIN (int, ACE_TCHAR *[])
{
int status = 0;
for (CORBA::ULong i = 16; i != 64; ++i)
{
ACE_Message_Block mb (i + ACE_CDR::MAX_ALIGNMENT);
ACE_CDR::mb_align (&mb);
mb.wr_ptr (i);
CORBA::Double dbl = i;
TAO_OutputCDR cdr;
cdr.write_ulong (i); // length
cdr.write_octet_array_mb (&mb);
cdr.write_double (dbl);
cdr.write_double (dbl);
TAO_InputCDR input (cdr);
CORBA::ULong len;
input.read_ulong (len);
if (len != i)
{
ACE_DEBUG ((LM_DEBUG,
"ERROR: mismatched lengths,"
" got %d, expected %d\n",
len, i));
}
ACE_Message_Block read_mb (len + ACE_CDR::MAX_ALIGNMENT);
ACE_CDR::mb_align (&mb);
mb.wr_ptr (len);
input.read_char_array (mb.rd_ptr (), len);
CORBA::Double read_dbl;
if (input.read_double (read_dbl) == 0)
ACE_DEBUG ((LM_DEBUG, "Failure reading double...\n"));
if (!ACE::is_equal (read_dbl, dbl))
{
status = 1;
ACE_DEBUG ((LM_DEBUG,
"ERROR: mismatched doubles,"
" got %f, expected %f\n",
read_dbl, dbl));
for (const ACE_Message_Block *j = cdr.begin ();
j != cdr.end ();
j = j->cont ())
{
ACE_HEX_DUMP ((LM_DEBUG,
j->rd_ptr (),
j->length (),
ACE_TEXT("Output CDR stream")));
}
TAO_InputCDR debug (cdr);
ACE_HEX_DUMP ((LM_DEBUG,
debug.rd_ptr (),
debug.length (),
ACE_TEXT("Input CDR stream")));
}
}
return status;
}
void
ReplicaController::send_reply (
PortableInterceptor::ServerRequestInfo_ptr ri)
{
FT::FTRequestServiceContext_var ftr (
extract_context (ri));
ACE_DEBUG ((LM_DEBUG,
"(%P|%t) Sending reply for %s with rid %i\n",
ftr->client_id.in (),
ftr->retention_id));
// Prepare reply for logging.
CORBA::Any_var result =
ri->result ();
TAO_OutputCDR cdr;
result->impl ()->marshal_value (cdr);
Dynamic::ParameterList_var pl =
ri->arguments ();
CORBA::ULong len = pl->length ();
for (CORBA::ULong index = 0; index != len ; ++index)
{
//@@ No chance for PARAM_OUT
if ((*pl)[index].mode == CORBA::PARAM_INOUT)
{
(*pl)[index].argument.impl ()->marshal_value (cdr);
}
}
CORBA::OctetSeq_var reply;
ACE_NEW (reply.out (), CORBA::OctetSeq (cdr.total_length ()));
reply->length (cdr.total_length ());
CORBA::Octet* buf = reply->get_buffer ();
// @@ What if this throws an exception?? We don't have any way to
// check whether this succeeded
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
// Logging the reply and state update.
//
// First send message to members.
//
{
// Extract state update.
CORBA::OctetSeq_var oid = ri->object_id ();
PortableInterceptor::AdapterName_var an = ri->adapter_name ();
CORBA::Any_var state = ri->get_slot (state_slot_id ());
CORBA::TypeCode_var tc = state->type ();
if (tc->kind () == CORBA::tk_null)
{
ACE_DEBUG ((LM_DEBUG, "Slot update is void\n"));
PortableServer::POA_var poa = resolve_poa (an.in ());
PortableServer::ServantBase_var servant =
poa->id_to_servant (oid.in ());
Checkpointable* target =
dynamic_cast<Checkpointable*> (servant.in ());
if (target)
{
CORBA::Any_var tmp = target->get_state ();
if (tmp.ptr () != 0) state = tmp._retn ();
}
}
TAO_OutputCDR cdr;
cdr << oid.in ();
cdr << an.in ();
cdr << ftr->client_id.in ();
cdr << ftr->retention_id;
cdr << reply.in ();
cdr << state.in ();
size_t size = cdr.total_length ();
CORBA::OctetSeq_var msg;
ACE_NEW (msg.out (), CORBA::OctetSeq (size));
msg->length (size);
{
CORBA::Octet* buf = msg->get_buffer ();
for (ACE_Message_Block const* mb = cdr.begin ();
mb != 0;
mb = mb->cont ())
{
ACE_OS::memcpy (buf, mb->rd_ptr (), mb->length ());
buf += mb->length ();
}
}
CORBA::Octet* buf = msg->get_buffer ();
// Crash point 1.
//
if (crash_point == 1 && ftr->retention_id > 2) ACE_OS::exit (1);
try
{
while (true)
{
try
{
group_->send (buf, size);
ACE_DEBUG ((LM_DEBUG, "Sent log record of length %i\n", size));
break;
}
catch (ACE_TMCast::Group::Aborted const&)
{
ACE_DEBUG ((LM_DEBUG, "Retrying to send log record.\n"));
}
}
}
catch (ACE_TMCast::Group::Failed const&)
{
ACE_DEBUG ((LM_DEBUG,
"Group failure. Perhaps, I am alone in the group.\n"));
}
}
// Now perform local logging.
//
RecordId rid (ftr->client_id.in (), ftr->retention_id);
// This is slow but eh-safe ;-).
//
log_.insert (rid, reply);
// Crash point 2.
//
if (crash_point == 2 && ftr->retention_id > 2) ACE_OS::exit (1);
}
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
bool
TAO::TypeCode::Struct<char const *,
CORBA::TypeCode_ptr const *,
TAO::TypeCode::Struct_Field<char const *,
CORBA::TypeCode_ptr const *> const *,
TAO::Null_RefCount_Policy>::tao_marshal (
TAO_OutputCDR & cdr,
CORBA::ULong offset) const
{
// A tk_struct TypeCode has a "complex" parameter list type (see
// Table 15-2 in Section 15.3.5.1 "TypeCode" in the CDR section of
// the CORBA specification), meaning that it must be marshaled into
// a CDR encapsulation.
// Create a CDR encapsulation.
TAO_OutputCDR enc;
// Account for the encoded CDR encapsulation length and byte order.
//
// Aligning on an octet since the next value after the CDR
// encapsulation length will always be the byte order octet/boolean
// in this case.
offset = ACE_Utils::truncate_cast<CORBA::ULong> (
ACE_align_binary (offset + 4,
ACE_CDR::OCTET_ALIGN));
bool const success =
(enc << TAO_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.id (), 0))
&& (enc << TAO_OutputCDR::from_string (this->base_attributes_.name (), 0))
&& (enc << this->nfields_);
if (!success)
return false;
Struct_Field<char const *, CORBA::TypeCode_ptr const *> const * const begin =
&this->fields_[0];
Struct_Field<char const *, CORBA::TypeCode_ptr const *> const * const end =
begin + this->nfields_;
for (Struct_Field<char const *, CORBA::TypeCode_ptr const *> const * i =
begin;
i != end;
++i)
{
Struct_Field<char const *, CORBA::TypeCode_ptr const *> const & field =
*i;
if (!(enc << TAO_OutputCDR::from_string (
Traits<char const *>::get_string (field.name), 0))
|| !marshal (enc,
Traits<char const *>::get_typecode (field.type),
ACE_Utils::truncate_cast<CORBA::ULong> (
offset + enc.total_length ())))
return false;
}
return
cdr << static_cast<CORBA::ULong> (enc.total_length ())
&& cdr.write_octet_array_mb (enc.begin ());
}
void TAO_FTEC_Group_Manager::add_member (
const FTRT::ManagerInfo & info,
CORBA::ULong object_group_ref_version)
{
TAO_FTRTEC::Log(1, ACE_TEXT("add_member location = <%s>\n"),
(const char*)info.the_location[0].id);
auto_ptr<TAO_FTEC_Group_Manager_Impl> new_impl(new TAO_FTEC_Group_Manager_Impl);
new_impl->my_position = impl_->my_position;
size_t pos = impl_->info_list.length();
new_impl->info_list.length(pos+1);
for (size_t i = 0; i < pos; ++i) {
new_impl->info_list[i] = impl_->info_list[i];
}
new_impl->info_list[pos] = info;
GroupInfoPublisherBase* publisher = GroupInfoPublisher::instance();
GroupInfoPublisherBase::Info_ptr group_info (
publisher->setup_info(new_impl->info_list,
new_impl->my_position,
object_group_ref_version));
int last_one = (impl_->my_position == impl_->info_list.length()-1);
if (!last_one)
{
// I am not the last of replica, tell my successor that
// a new member has joined in.
try{
FTRTEC::Replication_Service::instance()->add_member(info, object_group_ref_version);
}
catch (const CORBA::Exception&){
// Unable to send request to all the successors.
// Now this node become the last replica of the object group.
// update the info list again
new_impl->info_list.length(new_impl->my_position+2);
new_impl->info_list[new_impl->my_position+1] = info;
/// group_info = publisher->set_info(..) should be enough.
/// However, GCC 2.96 is not happy with that.
GroupInfoPublisherBase::Info_ptr group_info1 (
publisher->setup_info(new_impl->info_list,
new_impl->my_position,
object_group_ref_version));
ACE_auto_ptr_reset(group_info, group_info1.release());
last_one = true;
}
}
if (last_one)
{
// this is the last replica in the list
// synchornize the state with the newly joined replica.
FtRtecEventChannelAdmin::EventChannelState state;
get_state(state);
TAO_OutputCDR cdr;
cdr << state;
FTRT::State s;
if (cdr.begin()->cont()) {
ACE_Message_Block* blk;
ACE_NEW_THROW_EX(blk, ACE_Message_Block, CORBA::NO_MEMORY());
ACE_CDR::consolidate(blk, cdr.begin());
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
s.replace(blk->length(), blk);
#else
// If the replace method is not available, we will need
// to do the copy manually. First, set the octet sequence length.
CORBA::ULong length = blk->length ();
s.length (length);
// Now copy over each byte.
char* base = blk->data_block ()->base ();
for(CORBA::ULong i = 0; i < length; i++)
{
s[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
blk->release();
}
else {
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
s.replace(cdr.begin()->length(), cdr.begin());
#else
// If the replace method is not available, we will need
// to do the copy manually. First, set the octet sequence length.
CORBA::ULong length = cdr.begin ()->length ();
s.length (length);
// Now copy over each byte.
char* base = cdr.begin()->data_block ()->base ();
for(CORBA::ULong i = 0; i < length; i++)
{
s[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
}
TAO_FTRTEC::Log(2, ACE_TEXT("Setting state\n"));
info.ior->set_state(s);
info.ior->create_group(new_impl->info_list,
object_group_ref_version);
TAO_FTRTEC::Log(2, ACE_TEXT("After create_group\n"));
}
// commit the changes
IOGR_Maker::instance()->set_ref_version( object_group_ref_version );
publisher->update_info(group_info);
delete impl_;
impl_ = new_impl.release();
}
int
ECMS_Driver::supplier_task (Test_Supplier *supplier,
void* /* cookie */)
{
try
{
ACE_Time_Value tv (0, this->event_period_);
CORBA::ULong n = this->event_size_;
ECM_IDLData::Info info;
info.mobile_name = CORBA::string_dup ("test");
info.mobile_speed = 1;
info.trajectory.length (n);
ECM_Data other;
other.description = CORBA::string_dup ("some data");
for (CORBA::ULong j = 0; j < n; ++j)
{
info.trajectory[j].x = j;
info.trajectory[j].y = j * j;
other.inventory.bind (j, j + 1);
}
ACE_DEBUG ((LM_DEBUG,
"The inventory contains (%d) elements\n",
other.inventory.current_size ()));
// We have to make it big enough so we get a contiguous block,
// otherwise the octet sequence will not work correctly.
// NOTE: we could pre-allocate enough memory in the CDR stream
// but we want to show that chaining works!
TAO_OutputCDR cdr;
CORBA::Boolean byte_order = TAO_ENCAP_BYTE_ORDER;
cdr << CORBA::Any::from_boolean (byte_order);
// The typecode name standard, the encode method is not (in
// general the CDR interface is not specified).
if (!(cdr << info))
throw CORBA::MARSHAL ();
// Here we marshall a non-IDL type.
cdr << other;
if (!cdr.good_bit ())
ACE_ERROR ((LM_ERROR, "Problem marshalling C++ data\n"));
const ACE_Message_Block* mb = cdr.begin ();
// NOTE: total_length () return the length of the complete
// chain.
CORBA::ULong mblen = cdr.total_length ();
for (CORBA::Long i = 0; i < this->event_count_; ++i)
{
RtecEventComm::EventSet event (1);
event.length (1);
event[0].header.source = supplier->supplier_id ();
event[0].header.ttl = 1;
ACE_hrtime_t t = ACE_OS::gethrtime ();
ORBSVCS_Time::hrtime_to_TimeT (event[0].header.creation_time, t);
if (i == static_cast<CORBA::Long> (this->event_count_) - 1)
event[0].header.type = ACE_ES_EVENT_SHUTDOWN;
else if (i % 2 == 0)
event[0].header.type = this->event_a_;
else
event[0].header.type = this->event_b_;
// We use replace to minimize the copies, this should result
// in just one memory allocation;
#if (TAO_NO_COPY_OCTET_SEQUENCES == 1)
event[0].data.payload.replace (mblen, mb);
#else
// If the replace method is not available, we will need
// to do the copy manually. First, set the octet sequence length.
event[0].data.payload.length (mblen);
// Now copy over each byte.
char* base = mb->data_block ()->base ();
for(CORBA::ULong i = 0; i < mblen; i++)
{
event[0].data.payload[i] = base[i];
}
#endif /* TAO_NO_COPY_OCTET_SEQUENCES == 1 */
supplier->consumer_proxy ()->push(event);
// ACE_DEBUG ((LM_DEBUG, "(%t) supplier push event\n"));
ACE_OS::sleep (tv);
}
}
catch (const CORBA::SystemException& sys_ex)
{
sys_ex._tao_print_exception ("SYS_EX");
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("NON SYS EX");
}
return 0;
}
/*static*/ CORBA::Boolean
PG_Utils::set_tagged_component (
PortableGroup::ObjectGroup *&ior,
PortableGroup::TagGroupTaggedComponent &tg)
{
if (ior->_stubobj () == 0)
return 0;
// We need to apply the property for every profile in the IOR
TAO_MProfile &tmp_pfiles =
ior->_stubobj ()->base_profiles ();
// Create the output CDR stream
TAO_OutputCDR cdr;
IOP::TaggedComponent tagged_components;
tagged_components.tag = IOP::TAG_FT_GROUP;
// Encode the property in to the tagged_components
CORBA::Boolean retval =
PG_Utils::encode_properties (cdr,
tg);
if (retval == 0)
return retval;
// Get the length of the CDR stream
CORBA::ULong length = static_cast<CORBA::ULong> (cdr.total_length ());
// Set the length
tagged_components.component_data.length (length);
// Get the pointer to the underlying buffer
CORBA::Octet *buf =
tagged_components.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 ();
}
const IOP::TaggedComponent &tmp_tc = tagged_components;
// Get the profile count.
CORBA::ULong count =
ior->_stubobj ()->base_profiles ().profile_count ();
// Go through every profile and set the TaggedComponent field
for (CORBA::ULong p_idx = 0; p_idx < count ; ++p_idx)
{
// Get the tagged components in the profile
TAO_Tagged_Components &tag_comp =
tmp_pfiles.get_profile (p_idx)->tagged_components ();
// Finally set the <tagged_component> in the
// <TAO_Tagged_Component>
tag_comp.set_component (tmp_tc);
}
// Success
return 1;
}
