void
CORBA::SystemException::_tao_encode (TAO_OutputCDR &cdr) const
{
if (cdr.write_string (this->_rep_id ())
&& cdr.write_ulong (this->minor ())
&& cdr.write_ulong (this->completed ()))
{
return;
}
throw ::CORBA::MARSHAL ();
}
void
Delivery_Request::marshal (TAO_OutputCDR & cdr)
{
if (this->delivery_type_ != 0)
{
cdr.write_octet (this->delivery_type_);
CORBA::ULong dest_count =
ACE_Utils::truncate_cast<CORBA::ULong> (this->destination_id_.size ());
cdr.write_ulong (dest_count);
for (size_t ndest = 0; ndest < dest_count; ++ ndest)
{
cdr.write_ulong (this->destination_id_ [ndest]);
}
}
}
void
Routing_Slip::marshal (TAO_OutputCDR & cdr)
{
size_t request_count = this->delivery_requests_.size();
cdr.write_ulong (
ACE_Utils::truncate_cast<CORBA::ULong> (request_count - this->complete_requests_));
for (size_t nreq = 0; nreq < request_count; ++nreq)
{
Delivery_Request * request = this->delivery_requests_[nreq].get ();
if (request != 0)
{
request->marshal (cdr);
}
}
}
CORBA::Boolean
operator<< (TAO_OutputCDR & cdr, CORBA::Principal * x)
{
if (x != 0)
{
CORBA::ULong length = x->id.length ();
cdr.write_long (length);
cdr.write_octet_array (x->id.get_buffer (), length);
}
else
{
cdr.write_ulong (0);
}
return (CORBA::Boolean) cdr.good_bit ();
}
int
TAO_Log_Constraint_Visitor::visit_union_pos (
ETCL_Union_Pos *union_pos)
{
try
{
if (union_pos->union_value ()->accept (this) == 0)
{
TAO_ETCL_Literal_Constraint disc_val;
this->queue_.dequeue_head (disc_val);
TAO_DynUnion_i dyn_union;
dyn_union.init (this->current_member_.in ());
CORBA::TypeCode_var tc = this->current_member_->type ();
switch (disc_val.expr_type ())
{
case ETCL_INTEGER:
case ETCL_SIGNED:
case ETCL_UNSIGNED:
{
CORBA::Any disc_any;
CORBA::TypeCode_var disc_tc =
tc->discriminator_type ();
CORBA::TCKind disc_kind =
TAO_DynAnyFactory::unalias (disc_tc.in ());
switch (disc_kind)
{
case CORBA::tk_boolean:
disc_any <<= CORBA::Any::from_boolean ((CORBA::Boolean) disc_val);
break;
case CORBA::tk_short:
disc_any <<= (CORBA::Short) ((CORBA::Long) disc_val);
break;
case CORBA::tk_ushort:
disc_any <<= (CORBA::UShort) ((CORBA::ULong) disc_val);
break;
case CORBA::tk_long:
disc_any <<= (CORBA::Long) disc_val;
break;
case CORBA::tk_ulong:
disc_any <<= (CORBA::ULong) disc_val;
break;
case CORBA::tk_enum:
{
TAO_OutputCDR cdr;
cdr.write_ulong ((CORBA::ULong) disc_val);
TAO_InputCDR in_cdr (cdr);
TAO::Unknown_IDL_Type *unk = 0;
ACE_NEW_RETURN (unk,
TAO::Unknown_IDL_Type (disc_tc.in (),
in_cdr),
-1);
disc_any.replace (unk);
break;
}
// @@@ (JP) I don't think ETCL handles 64-bit
// integers at this point, and I also think that
// chars and/or wchars will just come out in the
// constraint as (w)strings of length 1.
case CORBA::tk_longlong:
case CORBA::tk_ulonglong:
case CORBA::tk_char:
case CORBA::tk_wchar:
default:
return -1;
}
DynamicAny::DynAny_var dyn_any =
TAO::MakeDynAnyUtils::make_dyn_any_t<const CORBA::Any &> (
disc_tc.in (),
disc_any);
dyn_union.set_discriminator (dyn_any.in ());
DynamicAny::DynAny_var u_member =
dyn_union.member ();
this->current_member_ =
u_member->to_any ();
break;
}
case ETCL_STRING:
{
const char *name = (const char *) disc_val;
CORBA::ULong count =
tc->member_count ();
const char *member_name = 0;
CORBA::ULong i = 0;
for (i = 0; i < count; ++i)
{
member_name = tc->member_name (i);
if (ACE_OS::strcmp (name, member_name) == 0)
{
break;
}
}
// If there's no match, member_label will throw
// CORBA::TypeCode::Bounds and the catch block will
// return -1;
this->current_member_ = tc->member_label (i);
break;
}
// The TAO_ETCL_Union_Value that was put on the queue
// shouldn't have any other type.
default:
return -1;
}
ETCL_Constraint *nested = union_pos->component ();
// If there's no nested component, then we just want the
// union member value on the queue. Otherwise, we want
// the member value in current_member_ while we visit
// the nested component.
if (nested == 0)
{
TAO_ETCL_Literal_Constraint lit (this->current_member_.ptr ());
this->queue_.enqueue_head (lit);
return 0;
}
else
{
return nested->accept (this);
}
}
else
{
return -1;
}
}
catch (const CORBA::Exception&)
{
return -1;
}
}
void
TAO_UnionDef_i::fetch_label (const ACE_Configuration_Section_Key member_key,
CORBA::UnionMember &member)
{
ACE_Configuration::VALUETYPE vt;
this->repo_->config ()->find_value (member_key,
"label",
vt);
if (vt == ACE_Configuration::STRING)
{
member.label <<= CORBA::Any::from_octet (0);
return;
}
u_int value = 0;
this->repo_->config ()->get_integer_value (member_key,
"label",
value);
CORBA::TypeCode_var tc =
this->discriminator_type_i ();
CORBA::TCKind kind = tc->kind ();
switch (kind)
{
case CORBA::tk_char:
member.label <<= CORBA::Any::from_char (static_cast<CORBA::Char> (value));
break;
case CORBA::tk_wchar:
member.label <<= CORBA::Any::from_wchar (static_cast<CORBA::WChar> (value));
break;
case CORBA::tk_boolean:
member.label <<= CORBA::Any::from_boolean (static_cast<CORBA::Boolean> (value));
break;
case CORBA::tk_short:
member.label <<= static_cast<CORBA::Short> (value);
break;
case CORBA::tk_ushort:
member.label <<= static_cast<CORBA::UShort> (value);
break;
case CORBA::tk_long:
member.label <<= static_cast<CORBA::Long> (value);
break;
case CORBA::tk_ulong:
member.label <<= static_cast<CORBA::ULong> (value);
break;
case CORBA::tk_longlong:
member.label <<= static_cast<CORBA::LongLong> (value);
break;
case CORBA::tk_ulonglong:
member.label <<= static_cast<CORBA::ULongLong> (value);
break;
case CORBA::tk_enum:
{
TAO_OutputCDR cdr;
cdr.write_ulong (static_cast<CORBA::ULong> (value));
TAO_InputCDR in_cdr (cdr);
TAO::Unknown_IDL_Type *impl = 0;
ACE_NEW (impl,
TAO::Unknown_IDL_Type (tc.in (),
in_cdr));
member.label.replace (impl);
break;
}
default:
break;
}
}
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 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
TAO_ECG_UDP_Sender::push (const RtecEventComm::EventSet &events)
{
if (events.length () == 0)
{
// ORBSVCS_DEBUG ((EC_FORMAT (DEBUG,
// "Nothing to multicast: "
// "0-length EventSet.")));
return;
}
// Send each event in a separate message.
// @@ TODO It is interesting to group events destined to the
// same mcast group in a single message.
for (u_int i = 0; i < events.length (); ++i)
{
// To avoid loops we keep a TTL field on the events and skip the
// events with TTL <= 0
if (events[i].header.ttl <= 0)
continue;
const RtecEventComm::Event& e = events[i];
// We need to modify the TTL field, but copying the entire event
// would be wasteful; instead we create a new header and only
// modify the header portion.
RtecEventComm::EventHeader header = e.header;
header.ttl--;
// Start building the message
TAO_OutputCDR cdr;
// Marshal as if it was a sequence of one element, notice how we
// marshal a modified version of the header, but the payload is
// marshal without any extra copies.
cdr.write_ulong (1);
if (!(cdr << header)
|| !(cdr << e.data))
throw CORBA::MARSHAL ();
ACE_INET_Addr inet_addr;
try
{
// Grab the right mcast group for this event...
RtecUDPAdmin::UDP_Address_var udp_addr;
this->addr_server_->get_address (header, udp_addr.out());
switch (udp_addr->_d())
{
case RtecUDPAdmin::Rtec_inet:
inet_addr.set(udp_addr->v4_addr().port,
udp_addr->v4_addr().ipaddr);
break;
case RtecUDPAdmin::Rtec_inet6:
#if defined (ACE_HAS_IPV6)
inet_addr.set_type(PF_INET6);
#endif
inet_addr.set_address(udp_addr->v6_addr().ipaddr,16,0);
inet_addr.set_port_number(udp_addr->v6_addr().port);
break;
}
}
catch (const ::CORBA::BAD_OPERATION &)
{
// server only supports IPv4
// Grab the right mcast group for this event...
RtecUDPAdmin::UDP_Addr udp_addr;
this->addr_server_->get_addr (header, udp_addr);
inet_addr.set (udp_addr.port, udp_addr.ipaddr);
}
this->cdr_sender_.send_message (cdr, inet_addr);
}
}
CORBA::Boolean
operator<< (TAO_OutputCDR &strm, const CORBA::AbstractBase_ptr abs)
{
CORBA::Boolean discriminator = true;
// We marshal a null abstract interface ptr as a discriminator
// plus null object reference (see CORBA::Object::marshal()
// and operator << for CORBA::Object).
if (CORBA::is_nil (abs))
{
// Marshal discriminator, then empty type hint.
strm << ACE_OutputCDR::from_boolean (discriminator);
return strm << CORBA::Object::_nil ();
}
if (abs->_is_objref ())
{
if (strm << ACE_OutputCDR::from_boolean (discriminator))
{
TAO_Stub *stubobj = abs->_stubobj ();
if (stubobj == 0)
{
return false;
}
// STRING, a type ID hint
if ((strm << stubobj->type_id.in ()) == 0)
{
return false;
}
const TAO_MProfile& mprofile = stubobj->base_profiles ();
CORBA::ULong const profile_count = mprofile.profile_count ();
if ((strm << profile_count) == 0)
{
return false;
}
// @@ The MProfile should be locked during this iteration, is there
// anyway to achieve that?
for (CORBA::ULong i = 0; i < profile_count; ++i)
{
const TAO_Profile *p = mprofile.get_profile (i);
if (p->encode (strm) == 0)
{
return false;
}
}
return (CORBA::Boolean) strm.good_bit ();
}
}
else
{
discriminator = false;
if (strm << ACE_OutputCDR::from_boolean (discriminator))
{
CORBA::ULong value_tag = TAO_OBV_GIOP_Flags::Value_tag_base
| TAO_OBV_GIOP_Flags::Type_info_single;
if ((strm.write_ulong (value_tag)) == 0)
{
return false;
}
if ((strm << abs->_tao_obv_repository_id ()) == 0)
{
return false;
}
return abs->_tao_marshal_v (strm);
}
}
return false;
}
// Specialized visit_scope method for unions only.
int
ifr_adding_visitor_union::visit_scope (UTL_Scope *node)
{
// If the union has members that are scopes but not unions,
// the regular visit_scope method should be called instead.
if (node->scope_node_type () != AST_Decl::NT_union)
{
return ifr_adding_visitor::visit_scope (node);
}
AST_Union *u = AST_Union::narrow_from_scope (node);
CORBA::ULong nfields = static_cast<CORBA::ULong> (u->nfields ());
this->members_.length (nfields);
AST_Field **f = 0;
// Index into members_.
CORBA::ULong index = 0;
try
{
// Visit each field.
for (CORBA::ULong i = 0; i < nfields; ++i)
{
if (u->field (f, i) != 0)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("(%N:%l) ifr_adding_visitor_union::")
ACE_TEXT ("visit_scope -")
ACE_TEXT (" field node access failed\n")
),
-1
);
}
AST_Type *ft = (*f)->field_type ();
bool defined_here = ft->is_child (this->scope_);
// If the union member is defined in the union, we have to
// do some visiting - otherwise we can just look up the entry.
if (defined_here)
{
if (ft->node_type () == AST_Decl::NT_union)
{
// Since the enclosing scope hasn't been created yet,
// we make a special visitor to create this member
// at global scope and move it into the union later.
ifr_adding_visitor_union visitor (ft);
if (ft->ast_accept (&visitor) == -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("(%N:%l) ifr_adding_visitor_union::")
ACE_TEXT ("visit_scope -")
ACE_TEXT (" failed to accept visitor\n")),
-1);
}
this->ir_current_ =
CORBA::IDLType::_duplicate (visitor.ir_current ());
}
else
{
if (ft->ast_accept (this) == -1)
{
ORBSVCS_ERROR_RETURN ((
LM_ERROR,
ACE_TEXT ("(%N:%l) ifr_adding_visitor_union::")
ACE_TEXT ("visit_scope -")
ACE_TEXT (" failed to accept visitor\n")),
-1);
}
}
}
else
{
// Updates ir_current_.
this->get_referenced_type (ft);
}
// Get the case label(s).
AST_UnionLabel *case_label = 0;
AST_UnionBranch *ub = AST_UnionBranch::narrow_from_decl (*f);
unsigned long len = ub->label_list_length ();
// If there are multiple case labels, we will have an element
// in the UnionMemberSeq for each label, not just for each member,
// so the list length and the loop terminator must both be
// increased accordingly.
if (len > 1)
{
this->members_.length (this->members_.length () + len - 1);
}
for (unsigned long j = 0; j < len; ++j)
{
case_label = ub->label (j);
// Is this a regular label or default label?
if (case_label->label_kind () == AST_UnionLabel::UL_label)
{
AST_Expression::AST_ExprValue *ev =
case_label->label_val ()->ev ();
// If the discriminator is an enum, we can't just insert
// a ulong into the Any member of struct UnionMember.
if (u->disc_type ()->node_type () == AST_Decl::NT_enum)
{
TAO_OutputCDR cdr;
cdr.write_ulong (ev->u.ulval);
TAO_InputCDR in_cdr (cdr);
TAO::Unknown_IDL_Type *unk = 0;
ACE_NEW_RETURN (unk,
TAO::Unknown_IDL_Type (
this->disc_tc_.in (),
in_cdr),
-1);
this->members_[index].label.replace (unk);
}
else
{
this->load_any (ev,
this->members_[index].label);
}
}
else // Default case label.
{
this->members_[index].label <<= CORBA::Any::from_octet (0);
}
this->members_[index].name =
CORBA::string_dup ((*f)->local_name ()->get_string ());
// IfR method create_union does not use this - it just needs
// to be non-zero for marshaling.
this->members_[index].type =
CORBA::TypeCode::_duplicate (CORBA::_tc_void);
this->members_[index++].type_def =
CORBA::IDLType::_duplicate (this->ir_current_.in ());
}
}
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception (
ACE_TEXT (
"ifr_adding_visitor_union::visit_scope"));
return -1;
}
return 0;
}
