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