TAO
2.1.3
|
Definitions of the GIOP specific stuff. More...
#include <GIOP_Message_Base.h>
Protected Attributes | |
Outgoing GIOP Fragment Related Attributes | |
These attributes are only used when fragmenting outgoing GIOP requests and replies. | |
auto_ptr < TAO_GIOP_Fragmentation_Strategy > | fragmentation_strategy_ |
TAO_OutputCDR | out_stream_ |
Buffer where the request is placed. |
Private Member Functions | |
bool | decompress (ACE_Data_Block **db, TAO_Queued_Data &qd, size_t &rd_pos, size_t &wr_pos) |
int | process_request (TAO_Transport *transport, TAO_InputCDR &input, TAO_OutputCDR &output, TAO_GIOP_Message_Generator_Parser *) |
Processes the GIOP_REQUEST messages. | |
int | process_locate_request (TAO_Transport *transport, TAO_InputCDR &input, TAO_OutputCDR &output, TAO_GIOP_Message_Generator_Parser *) |
Processes the GIOP_LOCATE_REQUEST messages. | |
TAO_GIOP_Message_Generator_Parser * | get_parser (const TAO_GIOP_Message_Version &version) const |
Get the parser. | |
int | dump_consolidated_msg (TAO_OutputCDR &stream) |
Print out consolidate messages. | |
void | dump_msg (const char *label, const u_char *ptr, size_t len) |
Print out a debug messages.. | |
int | write_protocol_header (GIOP::MsgType t, const TAO_GIOP_Message_Version &version, TAO_OutputCDR &msg) |
int | make_send_locate_reply (TAO_Transport *transport, TAO_GIOP_Locate_Request_Header &request, TAO_GIOP_Locate_Status_Msg &status, TAO_OutputCDR &output, TAO_GIOP_Message_Generator_Parser *) |
int | send_error (TAO_Transport *transport) |
Send error messages. | |
void | send_close_connection (const TAO_GIOP_Message_Version &version, TAO_Transport *transport) |
Close a connection, first sending GIOP::CloseConnection. | |
int | send_reply_exception (TAO_Transport *transport, TAO_OutputCDR &cdr, CORBA::ULong request_id, IOP::ServiceContextList *svc_info, CORBA::Exception *x) |
int | generate_locate_reply_header (TAO_OutputCDR &cdr, TAO_Pluggable_Reply_Params_Base ¶ms) |
Write the locate reply header. | |
TAO_Queued_Data * | make_queued_data (size_t sz) |
int | parse_request_id (const TAO_Queued_Data *qd, CORBA::ULong &request_id) const |
int | parse_request_id (const TAO_InputCDR &cdr, CORBA::ULong &request_id) const |
void | set_giop_flags (TAO_OutputCDR &msg) const |
Private Attributes | |
TAO_ORB_Core * | orb_core_ |
Cached ORB_Core pointer... | |
TAO_GIOP_Message_Generator_Parser_Impl | tao_giop_impl_ |
All the implementations of GIOP message generator and parsers. | |
TAO::Incoming_Message_Stack | fragment_stack_ |
Definitions of the GIOP specific stuff.
This class will hold the specific details common to all the GIOP versions. Some of them which are here may be shifted if things start changing between versions.
TAO_GIOP_Message_Base::TAO_GIOP_Message_Base | ( | TAO_ORB_Core * | orb_core, |
TAO_Transport * | transport, | ||
size_t | input_cdr_size = ACE_CDR::DEFAULT_BUFSIZE |
||
) |
Constructor.
TAO_GIOP_Message_Base::~TAO_GIOP_Message_Base | ( | void | ) |
Destructor.
int TAO_GIOP_Message_Base::consolidate_fragmented_message | ( | TAO_Queued_Data * | qd, |
TAO_Queued_Data *& | msg | ||
) |
Consolidate fragmented message with associated fragments, being stored within this class. If reliable transport is used (like TCP) fragments are partially ordered on stack, last fragment on top. Otherwise If un-reliable transport is used (like UDP) fragments may be dis-ordered, and must be ordered before consolidation.
int TAO_GIOP_Message_Base::consolidate_node | ( | TAO_Queued_Data * | qd, |
ACE_Message_Block & | incoming | ||
) |
Check whether the node qd needs consolidation from incoming.
|
private |
Decompresses a ZIOP message and turns it into a GIOP message When decompressed, db contains a complete new ACE_Data_Block and therefore qd its data block is also replaced.
int TAO_GIOP_Message_Base::discard_fragmented_message | ( | const TAO_Queued_Data * | cancel_request | ) |
Discard all fragments associated to request-id encoded in cancel_request. This operation will never be called concurrently by multiple threads nor concurrently to consolidate_fragmented_message
|
private |
Print out consolidate messages.
|
private |
Print out a debug messages..
int TAO_GIOP_Message_Base::extract_next_message | ( | ACE_Message_Block & | incoming, |
TAO_Queued_Data *& | qd | ||
) |
Extract the details of the next message from the incoming through qd. Returns 0 if the message header could not be parsed completely, returns a 1 if the message header could be parsed completely and returns -1 on error.
int TAO_GIOP_Message_Base::format_message | ( | TAO_OutputCDR & | cdr, |
TAO_Stub * | stub, | ||
TAO_ServerRequest * | req | ||
) |
Format the message. As we have not written the message length in the header, we make use of this opportunity to insert and format the message. (Called by client, for requests, provides stub pointer but not the req pointer; called by server, for replies, provides req pointer, not stub pointer.)
size_t TAO_GIOP_Message_Base::fragment_header_length | ( | const TAO_GIOP_Message_Version & | giop_version | ) | const |
The header length of a fragment.
TAO_GIOP_Fragmentation_Strategy * TAO_GIOP_Message_Base::fragmentation_strategy | ( | void | ) |
Outgoing GIOP message fragmentation strategy.
int TAO_GIOP_Message_Base::generate_exception_reply | ( | TAO_OutputCDR & | cdr, |
TAO_Pluggable_Reply_Params_Base & | params, | ||
const CORBA::Exception & | x | ||
) |
Generate a reply message with the exception ex.
int TAO_GIOP_Message_Base::generate_fragment_header | ( | TAO_OutputCDR & | cdr, |
CORBA::ULong | request_id | ||
) |
|
private |
Write the locate reply header.
int TAO_GIOP_Message_Base::generate_locate_request_header | ( | TAO_Operation_Details & | op, |
TAO_Target_Specification & | spec, | ||
TAO_OutputCDR & | cdr | ||
) |
Write the RequestHeader in to the cdr stream.
int TAO_GIOP_Message_Base::generate_reply_header | ( | TAO_OutputCDR & | cdr, |
TAO_Pluggable_Reply_Params_Base & | params | ||
) |
Write the reply header.
int TAO_GIOP_Message_Base::generate_request_header | ( | TAO_Operation_Details & | op, |
TAO_Target_Specification & | spec, | ||
TAO_OutputCDR & | cdr | ||
) |
Write the RequestHeader in to the cdr stream. The underlying implementation of the messaging should do the right thing.
|
private |
Get the parser.
size_t TAO_GIOP_Message_Base::header_length | ( | void | ) | const |
Header length.
void TAO_GIOP_Message_Base::init | ( | CORBA::Octet | major, |
CORBA::Octet | minor | ||
) |
Initialize the underlying state object based on the major and minor revision numbers
bool TAO_GIOP_Message_Base::is_ready_for_bidirectional | ( | TAO_OutputCDR & | msg | ) | const |
Is the messaging object ready for processing BiDirectional request/response?
|
private |
Creates a new node for the queue with a message block in the node of size sz.
|
private |
Make a GIOP_LOCATEREPLY and hand that over to the transport so that it can be sent over the connection.
TAO_OutputCDR & TAO_GIOP_Message_Base::out_stream | ( | void | ) |
int TAO_GIOP_Message_Base::parse_next_message | ( | TAO_Queued_Data & | qd, |
size_t & | mesg_length | ||
) |
Parse the details of the next message from the incoming and initializes attributes of qd.
0 | If the message header could not be parsed completely, |
1 | If the message header could be parsed completely |
-1 | On error. |
|
private |
Parse GIOP request-id of TAO_Queued_Data qd
|
private |
Parse GIOP request-id of TAO_InputCDR cdr.
|
private |
Processes the GIOP_LOCATE_REQUEST messages.
int TAO_GIOP_Message_Base::process_reply_message | ( | TAO_Pluggable_Reply_Params & | reply_info, |
TAO_Queued_Data * | qd | ||
) |
Parse the reply message that we received and return the reply information through reply_info
|
private |
Processes the GIOP_REQUEST messages.
int TAO_GIOP_Message_Base::process_request_message | ( | TAO_Transport * | transport, |
TAO_Queued_Data * | qd | ||
) |
Process the request message that we have received on the connection
|
private |
Close a connection, first sending GIOP::CloseConnection.
|
private |
Send error messages.
|
private |
We must send a LocateReply through transport, this request resulted in some kind of exception.
|
private |
Set GIOP message flags in message that has been marshaled into the output CDR stream msg.
|
private |
Writes the GIOP header in to msg
|
private |
All Fragments being received are stored on stack in reverse order, last top
|
protected |
Strategy that sends data currently marshaled into this TAO_OutputCDR stream if necessary.
|
private |
Cached ORB_Core pointer...
|
protected |
Buffer where the request is placed.
|
private |
All the implementations of GIOP message generator and parsers.