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