CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_codebase_url_indirection (TAO_InputCDR &strm, ACE_CString& codebase_url) { CORBA::Long offset = 0; if (!strm.read_long (offset) || offset >= 0) { return false; } void* pos = strm.rd_ptr () + offset - sizeof (CORBA::Long); if (strm.get_codebase_url_map()->get()->find (pos, codebase_url) != 0) { throw CORBA::INTERNAL (); } else if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_codebase_url_indirection, found %x=%C\n"), pos, codebase_url.c_str ())); } return 1; }
void TAO_ConstantDef_i::value_i (const CORBA::Any &value) { CORBA::TypeCode_var my_tc = this->type_i (); CORBA::TypeCode_var val_tc = value.type (); CORBA::Boolean const equal_tc = my_tc.in ()->equal (val_tc.in ()); if (!equal_tc) { return; } ACE_Message_Block *mb = 0; TAO::Any_Impl *impl = value.impl (); if (impl->encoded ()) { TAO::Unknown_IDL_Type *unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); mb = unk->_tao_get_cdr ().steal_contents (); } else { TAO_OutputCDR out; impl->marshal_value (out); TAO_InputCDR in (out); mb = in.steal_contents (); } ACE_Auto_Ptr<ACE_Message_Block> safe (mb); CORBA::TCKind kind = val_tc->kind (); switch (kind) { // The data for these types will be aligned to an 8-byte // boundary, while the rd_ptr may not. case CORBA::tk_double: case CORBA::tk_ulonglong: case CORBA::tk_longlong: case CORBA::tk_longdouble: mb->rd_ptr (ACE_ptr_align_binary (mb->rd_ptr (), ACE_CDR::MAX_ALIGNMENT)); break; default: break; } mb->crunch (); this->repo_->config ()->set_binary_value (this->section_key_, "value", mb->base (), mb->length ()); }
void Test::AMI_ControllerHandler::worker_finished_reply_stub ( TAO_InputCDR &_tao_in, ::Messaging::ReplyHandler_ptr _tao_reply_handler, ::CORBA::ULong reply_status) { // Retrieve Reply Handler object. Test::AMI_ControllerHandler_var _tao_reply_handler_object = Test::AMI_ControllerHandler::_narrow (_tao_reply_handler); // Exception handling switch (reply_status) { case TAO_AMI_REPLY_OK: { // Demarshall all the arguments. // Invoke the call back method. _tao_reply_handler_object->worker_finished ( ); break; } case TAO_AMI_REPLY_USER_EXCEPTION: case TAO_AMI_REPLY_SYSTEM_EXCEPTION: { const ACE_Message_Block* cdr = _tao_in.start (); ::CORBA::OctetSeq _tao_marshaled_exception ( static_cast <CORBA::ULong> (cdr->length ()), static_cast <CORBA::ULong> (cdr->length ()), reinterpret_cast <unsigned char*> (cdr->rd_ptr ()), 0 ); ::Messaging::ExceptionHolder* exception_holder_ptr = 0; ACE_NEW ( exception_holder_ptr, ::TAO::ExceptionHolder ( (reply_status == TAO_AMI_REPLY_SYSTEM_EXCEPTION), _tao_in.byte_order (), _tao_marshaled_exception, 0, 0, _tao_in.char_translator (), _tao_in.wchar_translator ()) ); ::Messaging::ExceptionHolder_var exception_holder_var = exception_holder_ptr; _tao_reply_handler_object->worker_finished_excep ( exception_holder_var ); break; } case TAO_AMI_REPLY_NOT_OK: // @@ Michael: Not even the spec mentions this case. // We have to think about this case. break; } }
bool Routing_Slip::unmarshal (TAO_Notify_EventChannelFactory &ecf, TAO_InputCDR & cdr) { CORBA::ULong count = 0; cdr.read_ulong (count); for (size_t nreq = 0; nreq < count; ++nreq) { ACE_CDR::Octet code = 0; while (cdr.read_octet(code)) { try { if (code == TAO_Notify_Method_Request_Dispatch::persistence_code) { Delivery_Request * prequest; ACE_NEW_THROW_EX ( prequest, Delivery_Request(this_ptr_, this->delivery_requests_.size ()), CORBA::NO_MEMORY ()); Delivery_Request_Ptr request(prequest); TAO_Notify_Method_Request_Dispatch_Queueable * method = TAO_Notify_Method_Request_Dispatch::unmarshal ( request, ecf, cdr); if (method != 0) { this->delivery_requests_.push_back (request); this->delivery_methods_.push_back (method); } } else if (code == TAO_Notify_Method_Request_Lookup::persistence_code) { Delivery_Request_Ptr request(new Delivery_Request(this_ptr_, this->delivery_requests_.size ())); TAO_Notify_Method_Request_Lookup_Queueable * method = TAO_Notify_Method_Request_Lookup::unmarshal ( request, ecf, cdr); if (method != 0) { this->delivery_requests_.push_back (request); this->delivery_methods_.push_back (method); } } } catch (const CORBA::Exception&) { // @@todo should we log this? // just ignore failures } } } return this->delivery_requests_.size () > 0; }
void TAO::Unknown_IDL_Type::_tao_decode (TAO_InputCDR & cdr) { // @@ (JP) The following code depends on the fact that // TAO_InputCDR does not contain chained message blocks, // otherwise <begin> and <end> could be part of // different buffers! // This will be the start of a new message block. char const * const begin = cdr.rd_ptr (); // Skip over the next argument. TAO::traverse_status const status = TAO_Marshal_Object::perform_skip (this->type_, &cdr); if (status != TAO::TRAVERSE_CONTINUE) { throw ::CORBA::MARSHAL (); } // This will be the end of the new message block. char const * const end = cdr.rd_ptr (); // The ACE_CDR::mb_align() call can shift the rd_ptr by up to // ACE_CDR::MAX_ALIGNMENT - 1 bytes. Similarly, the offset adjustment // can move the rd_ptr by up to the same amount. We accommodate // this by including 2 * ACE_CDR::MAX_ALIGNMENT bytes of additional // space in the message block. size_t const size = end - begin; ACE_Message_Block new_mb (size + 2 * ACE_CDR::MAX_ALIGNMENT); ACE_CDR::mb_align (&new_mb); ptrdiff_t offset = ptrdiff_t (begin) % ACE_CDR::MAX_ALIGNMENT; if (offset < 0) { offset += ACE_CDR::MAX_ALIGNMENT; } new_mb.rd_ptr (offset); new_mb.wr_ptr (offset + size); ACE_OS::memcpy (new_mb.rd_ptr (), begin, size); this->cdr_.reset (&new_mb, cdr.byte_order ()); this->cdr_.char_translator (cdr.char_translator ()); this->cdr_.wchar_translator (cdr.wchar_translator ()); this->cdr_.set_repo_id_map (cdr.get_repo_id_map ()); this->cdr_.set_codebase_url_map (cdr.get_codebase_url_map ()); this->cdr_.set_value_map (cdr.get_value_map ()); // Take over the GIOP version, the input cdr can have a different // version then our current GIOP version. ACE_CDR::Octet major_version; ACE_CDR::Octet minor_version; cdr.get_version (major_version, minor_version); this->cdr_.set_version (major_version, minor_version); }
/*static*/ CORBA::Boolean PG_Utils::get_tagged_component ( PortableGroup::ObjectGroup *&ior, PortableGroup::TagGroupTaggedComponent &tg) { if (ior->_stubobj () == 0) return 0; TAO_MProfile &mprofile = ior->_stubobj ()->base_profiles (); // Looking for a tagged component with a TAG_FT_GROUP flag. IOP::TaggedComponent tc; tc.tag = IOP::TAG_FT_GROUP; CORBA::ULong count = mprofile.profile_count (); for (CORBA::ULong i = 0; i < count; i++) { // Get the Tagged Components const TAO_Tagged_Components &pfile_tagged = mprofile.get_profile (i)->tagged_components (); // Look for the primary if (pfile_tagged.get_component (tc) == 1) { TAO_InputCDR cdr (reinterpret_cast<const char*> (tc.component_data.get_buffer ()), tc.component_data.length ()); CORBA::Boolean byte_order; cdr >> ACE_InputCDR::to_boolean (byte_order); if (!cdr.good_bit ()) return 0; cdr.reset_byte_order (static_cast<int> (byte_order)); cdr >> tg; if (cdr.good_bit ()) return 1; } }
CORBA::Boolean CORBA::ValueBase::_tao_read_repository_id_list (TAO_InputCDR& strm, Repository_Id_List& ids) { CORBA::Long num_ids = 0; if (!strm.read_long (num_ids)) { return 0; } if (num_ids == TAO_OBV_GIOP_Flags::Indirection_tag) { // Multiple repo id is not indirected. return 0; } else { for (CORBA::Long i = 0; i < num_ids; ++i) { ACE_CString id; if (!_tao_read_repository_id (strm, id)) { return 0; } ids.push_back (id); } } return 1; }
void CORBA::SystemException::_tao_decode (TAO_InputCDR &cdr) { // The string is read by the caller, to determine the exact type of // the exception. We just decode the fields... // cdr.read_string (this->id ()); CORBA::ULong tmp; if (cdr.read_ulong (this->minor_) && cdr.read_ulong (tmp)) { this->completed_ = CORBA::CompletionStatus (tmp); return; } throw ::CORBA::MARSHAL (); }
bool TAO_Operation_Details::demarshal_args (TAO_InputCDR &cdr) { try { for (CORBA::ULong i = 0; i != this->num_args_; ++i) { if (!((*this->args_[i]).demarshal (cdr))) return false; } cdr.reset_vt_indirect_maps (); } catch (...) { cdr.reset_vt_indirect_maps (); throw; } return true; }
void TAO_AMH_DSI_Response_Handler::gateway_exception_reply ( CORBA::ULong reply_status, TAO_InputCDR &encap) { // for this to be effective, ACE & TAO must be built with // ACE_ENABLE_SWAP_ON_WRITE defined in ace/config.h this->_tao_out.reset_byte_order(encap.byte_order()); // This reply path handles only user exceptions. switch (reply_status) { //case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: case TAO_AMI_REPLY_USER_EXCEPTION: this->reply_status_ = GIOP::USER_EXCEPTION; break; case TAO_AMI_REPLY_SYSTEM_EXCEPTION: this->reply_status_ = GIOP::SYSTEM_EXCEPTION; break; // we don't handle location forward at this moment. // need to be addressed later. // //case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: // this->exception_type_ = TAO_GIOP_LOCATION_FORWARD; // break; } try { this->_tao_rh_init_reply (); // We know nothing about this exception, so we marshal it as a block // of bytes. The outgoing stream's byte order has already been matched // to the original source of the reply. this->_tao_out.write_octet_array_mb (encap.start()); // This will prevent the marshaling of any parameters into this reply. // this->sent_gateway_exception_ = 1; this->_tao_rh_send_reply (); } catch (const CORBA::Exception &) { // TODO: } }
CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_value_indirection_pre (TAO_InputCDR &strm, TAO_InputCDR &indirected_strm) { CORBA::Long offset = 0; if (!strm.read_long (offset) || offset >= 0) { return false; } size_t const buffer_size = -(offset) + sizeof (CORBA::Long); // Cribbed from tc_demarshal_indirection in Typecode_CDR_Extraction.cpp indirected_strm = TAO_InputCDR (strm.rd_ptr () + offset - sizeof (CORBA::Long), buffer_size, strm.byte_order ()); indirected_strm.set_repo_id_map (strm.get_repo_id_map ()); indirected_strm.set_codebase_url_map (strm.get_codebase_url_map ()); indirected_strm.set_value_map (strm.get_value_map ()); return indirected_strm.good_bit (); }
CORBA::Boolean TAO_DynEnum_i::equal (DynamicAny::DynAny_ptr rhs) { CORBA::TypeCode_var tc = rhs->type (); CORBA::Boolean equivalent = tc->equivalent (this->type_.in ()); if (!equivalent) { return false; } CORBA::Any_var any = rhs->to_any (); TAO::Any_Impl *impl = any->impl (); CORBA::ULong value; if (impl->encoded ()) { TAO::Unknown_IDL_Type * const unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); if (!unk) throw CORBA::INTERNAL (); // We don't want unk's rd_ptr to move, in case we are shared by // another Any, so we use this to copy the state, not the buffer. TAO_InputCDR for_reading (unk->_tao_get_cdr ()); for_reading.read_ulong (value); } else { TAO_OutputCDR out; impl->marshal_value (out); TAO_InputCDR in (out); in.read_ulong (value); } return value == this->value_; }
bool Lorica::EvaluatorBase::evaluate_exception(const char *, PortableServer::POA_ptr, const char *ex_type, TAO_InputCDR &incoming, TAO_OutputCDR &encap ) const { const ACE_Message_Block *buffer = incoming.start(); encap << ex_type; encap.write_octet_array_mb (buffer); return true; }
CORBA::Boolean TAO_ChunkInfo::skip_chunks (TAO_InputCDR &strm) { if (!this->chunking_) { return 1; } // This function is called after reading data of the truncated parent and // skips the remaining chunks until the outmost endtag (-1). // The tag read here is suppoused to be an endtag. CORBA::Long tag; if (!strm.read_long(tag)) { return 0; } // end of the whole valuetype. if (tag == -1) { return 1; } else if (tag < 0) { // continue skip the chunk. return this->skip_chunks (strm); } else if (tag < TAO_OBV_GIOP_Flags::Value_tag_base) { // Read the chunk size and move forward to skip the data. ACE_Message_Block* current = const_cast<ACE_Message_Block*>(strm.start ()); current->rd_ptr (tag); return this->skip_chunks (strm); } else return 0; }
void TAO_DynEnum_i::init (const CORBA::Any &any) { CORBA::TypeCode_var tc = any.type (); CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()); if (kind != CORBA::tk_enum) { throw DynamicAny::DynAnyFactory::InconsistentTypeCode (); } this->type_ = tc; TAO::Any_Impl *impl = any.impl (); if (impl->encoded ()) { TAO::Unknown_IDL_Type * const unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); if (!unk) throw CORBA::INTERNAL (); // We don't want unk's rd_ptr to move, in case we are shared by // another Any, so we use this to copy the state, not the buffer. TAO_InputCDR for_reading (unk->_tao_get_cdr ()); for_reading.read_ulong (this->value_); } else { TAO_OutputCDR out; impl->marshal_value (out); TAO_InputCDR in (out); in.read_ulong (this->value_); } this->init_common (); }
static int test_read (TAO_InputCDR &cdr, int n) { CORBA::Long xl; for (int i = 0; i < n; ++i) { if (cdr.read_long (xl) == 0) ACE_ERROR_RETURN ((LM_ERROR, "read_long[%d] failed\n", i), 1); } return 0; }
void CORBA::Request::handle_response (TAO_InputCDR &incoming, GIOP::ReplyStatusType reply_status) { // If this request was created by a gateway, then result_ // and/or args_ are shared by a CORBA::ServerRequest, whose // reply must be in the same byte order as the reply we are // handling here. So we set the member to be accessed later. this->byte_order_ = incoming.byte_order (); switch (reply_status) { case GIOP::NO_EXCEPTION: if (this->result_ != 0) { // We can be sure that the impl is a TAO::Unknown_IDL_Type. this->result_->value ()->impl ()->_tao_decode (incoming); } this->args_->_tao_incoming_cdr (incoming, CORBA::ARG_OUT | CORBA::ARG_INOUT, this->lazy_evaluation_); { ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->lock_); this->response_received_ = true; } break; case GIOP::USER_EXCEPTION: case GIOP::SYSTEM_EXCEPTION: case GIOP::LOCATION_FORWARD: case GIOP::LOCATION_FORWARD_PERM: default: // @@ (JP) Don't know what to do about any of these yet. TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) unhandled reply status\n"))); } }
CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_value_indirection (TAO_InputCDR &strm, CORBA::ValueBase *&value) { if (strm.get_value_map().is_nil ()) throw CORBA::INTERNAL (); CORBA::Long offset = 0; if (!strm.read_long (offset) || offset >= 0) { return 0; } void* pos = strm.rd_ptr () + offset - sizeof (CORBA::Long); if (9 < TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) ValueBase::_tao_unmarshal_value_indirection, pos %x\n"), pos)); TAO_InputCDR::Value_Map* map = strm.get_value_map()->get (); for (TAO_InputCDR::Value_Map::ITERATOR it = map->begin (); it != map->end (); ++ it) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) ValueBase::_tao_unmarshal_value_indirection, %x=%x\n"), it->ext_id_, it->int_id_)); } } void * v = 0; if (strm.get_value_map()->get()->find (pos, v) != 0) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ") ACE_TEXT ("ValueBase::_tao_unmarshal_value_indirection, ") ACE_TEXT ("did not find %x in map %x\n"), pos, (void *) strm.get_value_map()->get())); throw CORBA::INTERNAL (); } else if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_value_indirection, found %x=%x\n"), pos,v)); } value = reinterpret_cast<CORBA::ValueBase *>(v); return true; }
CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_pre ( TAO_InputCDR &strm, CORBA::ValueBase *&valuetype, const char *const fallback_repo_id, CORBA::Boolean &is_null_object, CORBA::Boolean &is_indirected) { // %! yet much to do ... look for +++ ! // 1. Get the <value-tag> (else it may be <indirection-tag> or <null-ref>). // Is object yet unmarshalled (<indirection-tag> is set) ? (->1a) // Is <null-ref> given ? Set 0 and return ok. // 1a. Lookup the real address in memory, which should be aligned +++ // to CORBA::ValueBase. Its possible at this point that worse // type mismatch gets by undetected, if the CDR stream fakes. // So the type should be checked ... +++ // 2. Now at this point it must be a <value-tag> (error else). // if (chunking) check that any last chunk ends with matching // size. If not raise marshal exception. // Increase the nesting level of valuetypes. // 3. if (chunking) read and record the blocksize-tag. // 4. Unmarshal type information and lookup factory. // If no type information is given in the CDR encoding, as told // from the <value-tag>, then use the repository id parameter // (it _must_ be right). CORBA::Boolean is_chunked = false; // Save the position of the start of the ValueType // to allow caching for later indirection. if (strm.align_read_ptr (ACE_CDR::LONG_SIZE)) { return false; } void *const start_of_valuetype = strm.rd_ptr(); Repository_Id_List ids; CORBA::Boolean result = CORBA::ValueBase::_tao_unmarshal_header ( strm, fallback_repo_id, ids, is_null_object, is_indirected, is_chunked); if (!result || is_null_object) { valuetype = 0; return result; } if (is_indirected) { return _tao_unmarshal_value_indirection (strm, valuetype); } CORBA::ValueBase::_tao_unmarshal_find_factory ( strm, start_of_valuetype, valuetype, ids, is_chunked); return true; }
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:: listener () { try { for (char buffer[1024];;) { size_t n = group_->recv (buffer, sizeof (buffer)); ACE_HEX_DUMP ((LM_DEBUG, buffer, n)); TAO_InputCDR cdr (buffer, n); CORBA::OctetSeq object_id; PortableInterceptor::AdapterName adapter_name; CORBA::String_var client_id; CORBA::Long retention_id; CORBA::OctetSeq reply; CORBA::Any state; cdr >> object_id; cdr >> adapter_name; cdr >> client_id.out (); cdr >> retention_id; cdr >> reply; cdr >> state; if (!cdr.good_bit ()) { ACE_DEBUG ((LM_DEBUG, "CDR failed\n")); //@@ what to do? } ACE_DEBUG ((LM_DEBUG, "Received log for %s with rid %i\n", client_id.in (), retention_id)); RecordId rid (client_id.in (), retention_id); CORBA::OctetSeq_var tmp (new CORBA::OctetSeq (reply)); log_.insert (rid, tmp); // Update state. CORBA::TypeCode_var tc = state.type (); if (tc->kind () != CORBA::tk_null) { PortableServer::POA_var poa = resolve_poa (adapter_name); PortableServer::ServantBase_var servant = poa->id_to_servant (object_id); Checkpointable* target = dynamic_cast<Checkpointable*> (servant.in ()); if (target) target->set_state (state); } } } catch (ACE_TMCast::Group::Failed const&) { ACE_DEBUG ((LM_DEBUG, "Group failure. Perhaps, I am alone in the group.\n")); } catch (ACE_TMCast::Group::InsufficienSpace const&) { ACE_DEBUG ((LM_DEBUG, "Group::InsufficienSpace\n")); } orb_->shutdown (0); }
Invocation_Status DII_Invocation::handle_user_exception (TAO_InputCDR &cdr) { Reply_Guard mon (this, TAO_INVOKE_FAILURE); if (TAO_debug_level > 3) { TAOLIB_DEBUG ((LM_DEBUG, "TAO (%P|%t) - DII_Invocation::" "handle_user_exception\n")); } // Match the exception interface repository id with the // exception in the exception list. // This is important to decode the exception. CORBA::String_var buf; TAO_InputCDR tmp_stream (cdr, cdr.start ()->length (), 0); // Pull the exception ID out of the marshaling buffer. if (tmp_stream.read_string (buf.inout ()) == 0) { throw ::CORBA::MARSHAL (TAO::VMCID, CORBA::COMPLETED_YES); } for (CORBA::ULong i = 0; this->excp_list_ != 0 && i < this->excp_list_->count (); i++) { CORBA::TypeCode_var tc = this->excp_list_->item (i); const char *xid = tc->id (); if (ACE_OS::strcmp (buf.in (), xid) != 0) { continue; } CORBA::Any any; TAO::Unknown_IDL_Type *unk = 0; ACE_NEW_RETURN (unk, TAO::Unknown_IDL_Type ( tc.in (), cdr ), TAO_INVOKE_FAILURE); any.replace (unk); mon.set_status (TAO_INVOKE_USER_EXCEPTION); throw ::CORBA::UnknownUserException (any); } // If we couldn't find the right exception, report it as // CORBA::UNKNOWN. // But first, save the user exception in case we // are being used in a TAO gateway. this->host_->raw_user_exception (cdr); mon.set_status (TAO_INVOKE_USER_EXCEPTION); // @@ It would seem that if the remote exception is a // UserException we can assume that the request was // completed. throw ::CORBA::UNKNOWN (TAO::VMCID, CORBA::COMPLETED_YES); }
void TAO_DynSequence_i::init (const CORBA::Any& any) { CORBA::TypeCode_var tc = any.type (); CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()); if (kind != CORBA::tk_sequence) { throw DynamicAny::DynAnyFactory::InconsistentTypeCode (); } this->type_ = tc; // Get the CDR stream of the Any, if there isn't one, make one. TAO::Any_Impl *impl = any.impl (); CORBA::ULong length; TAO_OutputCDR out; TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0)); if (impl->encoded ()) { TAO::Unknown_IDL_Type * const unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); if (!unk) throw CORBA::INTERNAL (); cdr = unk->_tao_get_cdr (); } else { impl->marshal_value (out); TAO_InputCDR tmp_in (out); cdr = tmp_in; } // If the any is a sequence, first 4 bytes of cdr hold the // length. cdr.read_ulong (length); // Resize the array. this->da_members_.size (length); this->init_common (); // Get the type of the sequence elments. CORBA::TypeCode_var field_tc = this->get_element_type (); for (CORBA::ULong i = 0; i < length; ++i) { CORBA::Any field_any; TAO_InputCDR unk_in (cdr); TAO::Unknown_IDL_Type *field_unk = 0; ACE_NEW (field_unk, TAO::Unknown_IDL_Type (field_tc.in (), unk_in)); field_any.replace (field_unk); // This recursive step will call the correct constructor // based on the type of field_any. this->da_members_[i] = TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> ( field_any._tao_get_typecode (), field_any, this->allow_truncation_ ); // Move to the next field in the CDR stream. (void) TAO_Marshal_Object::perform_skip (field_tc.in (), &cdr); } }
void TAO_DynSequence_i::from_any (const CORBA::Any & any) { if (this->destroyed_) { throw ::CORBA::OBJECT_NOT_EXIST (); } CORBA::TypeCode_var tc = any.type (); CORBA::Boolean equivalent = this->type_.in ()->equivalent (tc.in ()); if (equivalent) { // Get the CDR stream of the Any, if there isn't one, make one. TAO::Any_Impl *impl = any.impl (); TAO_OutputCDR out; TAO_InputCDR cdr (static_cast<ACE_Message_Block *> (0)); if (impl->encoded ()) { TAO::Unknown_IDL_Type * const unk = dynamic_cast<TAO::Unknown_IDL_Type *> (impl); if (!unk) throw CORBA::INTERNAL (); cdr = unk->_tao_get_cdr (); } else { impl->marshal_value (out); TAO_InputCDR tmp_in (out); cdr = tmp_in; } CORBA::ULong arg_length; // If the any is a sequence, first 4 bytes of cdr hold the // length. cdr.read_ulong (arg_length); // If the array grows, we must do it now. if (arg_length > this->component_count_) { this->da_members_.size (arg_length); } CORBA::TypeCode_var field_tc = this->get_element_type (); for (CORBA::ULong i = 0; i < arg_length; ++i) { CORBA::Any field_any; TAO_InputCDR unk_in (cdr); TAO::Unknown_IDL_Type *field_unk = 0; ACE_NEW (field_unk, TAO::Unknown_IDL_Type (field_tc.in (), unk_in)); field_any.replace (field_unk); if (i < this->component_count_) { this->da_members_[i]->destroy (); } this->da_members_[i] = TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any&> ( field_any._tao_get_typecode (), field_any, this->allow_truncation_ ); // Move to the next field in the CDR stream. (void) TAO_Marshal_Object::perform_skip (field_tc.in (), &cdr); } // Destroy any dangling members. for (CORBA::ULong j = arg_length; j < this->component_count_; ++j) { this->da_members_[j]->destroy (); } // If the array shrinks, we must wait until now to do it. if (arg_length < this->component_count_) { this->da_members_.size (arg_length); } // Now we can update component_count_. this->component_count_ = arg_length; this->current_position_ = arg_length ? 0 : -1; } else { throw DynamicAny::DynAny::TypeMismatch (); } }
CORBA::Boolean TAO_ChunkInfo::handle_chunking (TAO_InputCDR &strm) { if (!this->chunking_) { return 1; } char* the_rd_ptr = strm.start()->rd_ptr (); //This case could happen if a handle_chunking() reads a chunk size //and then calls the handle_chunking() again without reading the chunk data. //The handle_chunking() called continuously without reading the chunk data //only happens at the beginning of _tao_unmarshal_state() in a valuetype //that has parents. if (the_rd_ptr < this->chunk_octets_end_pos_) { ++this->value_nesting_level_; return 1; } //Safty check if reading is out of range of current chunk. if (this->chunk_octets_end_pos_ != 0 && the_rd_ptr > this->chunk_octets_end_pos_) { return 0; } // Read a long value that might be an endtag, the chunk size or the value tag // of the nested valuetype. CORBA::Long tag; if (!strm.read_long (tag)) { return 0; } if (tag < 0) { // tag is an end tag if (-tag > this->value_nesting_level_) { TAOLIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - %N:%l TAO_ChunkInfo::handle_chunking, received end tag ") ACE_TEXT ("%d > value_nesting_level %d\n"), -tag, this->value_nesting_level_), 0); } this->value_nesting_level_ = - tag; --this->value_nesting_level_; this->chunk_octets_end_pos_ = 0; // Continue reading so that we can read the outmost endtag. This // would simplify the implementation in the derived valuetype. if (this->value_nesting_level_ > 0) { this->handle_chunking(strm); } } else if (tag < TAO_OBV_GIOP_Flags::Value_tag_base) { // Read the chunk size of another chunk. this->chunk_octets_end_pos_ = strm.rd_ptr () + tag; ++this->value_nesting_level_; } else // (tag >= 0x7fffff00) { // This should not happen since the valuetag of the nested // values are always unmarshalled in the // ValueBase::_tao_unmarshal_pre(). return 0; } return 1; }
CORBA::Boolean CORBA::ValueBase::_tao_read_codebase_url (TAO_InputCDR& strm, ACE_CString& codebase_url) { CORBA::ULong length = 0; size_t buffer_size = strm.length(); if (!strm.read_ulong (length)) { return 0; } VERIFY_MAP (TAO_InputCDR, codebase_url_map, Codebase_URL_Map); char * pos = strm.rd_ptr(); // 'length' may not be the codebase url length - it could be the // FFFFFFF indirection marker instead. If it is an indirection marker, we // get the offset following the indirection marker, otherwise we can follow // the same logic using the offset to simply rewind to the start of length // and re-read the length as part of the string if (TAO_OBV_GIOP_Flags::is_indirection_tag (length)) { return _tao_unmarshal_codebase_url_indirection (strm, codebase_url); } pos -= sizeof (CORBA::ULong); // Cribbed from tc_demarshal_indirection in Typecode_CDR_Extraction.cpp TAO_InputCDR url_stream (pos, buffer_size, strm.byte_order ()); if (!url_stream.good_bit ()) { return 0; } if (! url_stream.read_string (codebase_url)) return 0; // It's possible the codebase url is read again from an indirection stream, // so make sure the codebase url is the same. ACE_CString mapped_url; if (strm.get_codebase_url_map ()->get()->find (pos, mapped_url) == 0) { if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_read_codebase_url, found %x=%C\n"), pos, mapped_url.c_str ())); } if (ACE_OS::strcmp (mapped_url.c_str (), codebase_url.c_str ()) != 0) throw CORBA::INTERNAL (); } else if (strm.get_codebase_url_map ()->get()->bind (pos, codebase_url) != 0) { throw CORBA::INTERNAL (); } else { if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_read_codebase_url, bound %x=%C\n"), pos, codebase_url.c_str ())); } } // Since the codebase url is always read from the indirection cdr we have to skip // the main CDR forward if we were in fact reading from the current // location and not rewinding back some offset. strm.skip_bytes (length); return 1; }
CORBA::Boolean CORBA::ValueBase::_tao_unmarshal_header ( TAO_InputCDR &strm, const char *const fallback_repo_id, Repository_Id_List &ids, CORBA::Boolean &is_null_object, CORBA::Boolean &is_indirected, CORBA::Boolean &is_chunked) { is_indirected = false; is_null_object = false; is_chunked = false; CORBA::Long valuetag; if (!strm.read_long (valuetag)) { return false; } is_chunked = TAO_OBV_GIOP_Flags::is_chunked (valuetag); if (TAO_OBV_GIOP_Flags::is_null_ref (valuetag)) { // null reference is unmarshalled. is_null_object = true; return true; } if (TAO_OBV_GIOP_Flags::is_indirection_tag (valuetag)) { // value is redirected is_indirected = true; return true; } if (TAO_OBV_GIOP_Flags::has_codebase_url (valuetag)) { // We don't do anything with this url, but it needs // to be read and ignored. ACE_CString codebase_url; if (!_tao_read_codebase_url (strm, codebase_url)) { return false; } } // Obtain the repo_id(s) of the type we are reading if (TAO_OBV_GIOP_Flags::has_single_type_info (valuetag)) { ACE_CString id; if (!_tao_read_repository_id(strm, id)) { return false; } ids.push_back (id); } else if (TAO_OBV_GIOP_Flags::has_list_type_info (valuetag)) { if (!_tao_read_repository_id_list(strm, ids)) { return false; } } else if (TAO_OBV_GIOP_Flags::has_no_type_info (valuetag)) { if (fallback_repo_id) { ids.push_back (fallback_repo_id); } else { TAOLIB_ERROR (( LM_ERROR, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_pre, ") ACE_TEXT ("unknown repo_id\n") )); return false; } } else { if (TAO_debug_level) { TAOLIB_ERROR (( LM_ERROR, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_pre, ") ACE_TEXT ("unknown value tag: %x\n"), valuetag )); } return false; } return true; }
CORBA::Boolean CORBA::ValueBase::_tao_validate_box_type (TAO_InputCDR &strm, TAO_InputCDR &indirected_strm, const char * const repo_id_expected, CORBA::Boolean & null_object, CORBA::Boolean & is_indirected) { CORBA::Long value_tag; null_object = false; is_indirected = false; if (!strm.read_long (value_tag)) { return false; } if (TAO_OBV_GIOP_Flags::is_null_ref (value_tag)) { // ok, null reference unmarshaled null_object = true; return true; } if (TAO_OBV_GIOP_Flags::is_indirection_tag (value_tag)) { is_indirected = true; // box value is redirected. return _tao_unmarshal_value_indirection_pre (strm, indirected_strm); } if (!TAO_OBV_GIOP_Flags::is_value_tag (value_tag)) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l CORBA::ValueBase::_tao_validate_box_type, ") ACE_TEXT ("not value_tag\n"))); return false; } if (TAO_OBV_GIOP_Flags::has_codebase_url (value_tag)) { // Demarshal the codebase url (but we won't be using it). ACE_CString codebase_url; if (! _tao_read_codebase_url (strm, codebase_url)) { return false; } } if (TAO_OBV_GIOP_Flags::has_no_type_info (value_tag)) { // No type information so assume it is the correct type. return true; } if (TAO_OBV_GIOP_Flags::has_single_type_info (value_tag)) { // Demarshal the repository id and check if it is the expected one. ACE_CString id; if (! _tao_read_repository_id (strm, id)) { return false; } if (!ACE_OS::strcmp (id.c_str(), repo_id_expected)) { // Repository ids matched as expected return true; } } if (TAO_OBV_GIOP_Flags::has_list_type_info (value_tag)) { // Don't know how to handle a repository id list. It does not // make sense for a value box anyway. return false; } return false; }
void CORBA::ValueBase::_tao_unmarshal_find_factory ( TAO_InputCDR &strm, void *const start_of_valuetype, CORBA::ValueBase *&valuetype, Repository_Id_List &ids, CORBA::Boolean &is_chunked) { valuetype = 0; TAO_ORB_Core *orb_core = strm.orb_core (); if (!orb_core) { orb_core = TAO_ORB_Core_instance (); if (TAO_debug_level) { TAOLIB_DEBUG (( LM_WARNING, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ") ACE_TEXT ("WARNING: extracting valuetype using default ORB_Core\n") )); } } // Find the registered factory for this unmarshalling valuetype. If any // factory for the valuetype in its truncatable derivation hierarchy // is registered, the factory is used to create value for unmarshalling. // Value factories are reference counted. When we get a new value factory // from the ORB, its reference count is increased. CORBA::ValueFactory_var factory; CORBA::Boolean requires_truncation = false; const size_t num_ids = ids.size (); const char *id = (num_ids) ? ids[0].c_str () : "{Null}"; for (size_t i = 0u; i < num_ids; ++i) { factory = orb_core->orb ()->lookup_value_factory (ids[i].c_str ()); if (factory.in() != 0) { id = ids[i].c_str (); requires_truncation = (i != 0u); break; } } // Obtain the actual ValueType from the factory if (factory.in() == 0 || !(valuetype = factory->create_for_unmarshal ())) { if (TAO_debug_level) { TAOLIB_ERROR ((LM_ERROR, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ") ACE_TEXT ("OBV factory is null, id=%C\n"), id)); } throw ::CORBA::MARSHAL (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE); } if (requires_truncation) { valuetype->truncation_hook (); } valuetype->chunking_ = is_chunked; // Cache the start of this ValueType for later possiable indirection VERIFY_MAP (TAO_InputCDR, value_map, Value_Map); if (strm.get_value_map ()->get()->bind (start_of_valuetype, valuetype) != 0) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ") ACE_TEXT ("Failed to bound value %x=%x, id=%C\n"), start_of_valuetype, valuetype, id )); } else if (TAO_debug_level) { TAOLIB_DEBUG ((LM_DEBUG, ACE_TEXT ("TAO (%P|%t) - %N:%l ValueBase::_tao_unmarshal_find_factory, ") ACE_TEXT ("bound value %x=%x, id=%C\n"), start_of_valuetype, valuetype, id )); } }