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; }