diff options
Diffstat (limited to 'TAO/tao/giop.h')
| -rw-r--r-- | TAO/tao/giop.h | 372 |
1 files changed, 372 insertions, 0 deletions
diff --git a/TAO/tao/giop.h b/TAO/tao/giop.h new file mode 100644 index 00000000000..45472a9b1b1 --- /dev/null +++ b/TAO/tao/giop.h @@ -0,0 +1,372 @@ +// This may look like C, but it's really -*- C++ -*- + +// ============================================================================ +// +// = LIBRARY +// TAO +// +// = FILENAME +// giop.h +// +// = DESCRIPTION +// GIOP data structures and support routines +// +// Note that some symbols in this module are part of the +// "Internet" Inter-ORB Protocol (IIOP), not the General IOP. +// Only addressing information and certain details of connection +// usage are specific to IIOP; all other protocol details can be +// reused by ORB protocols that are built atop connection +// protocols other than TCP. +// +// THREADING NOTE: Threads should never manipulate another +// thread's invocations. In this implementation, all data +// structures used to represent invocations (and parts of them) +// are owned by the thread which created them. Multiple threads +// may make of course concurrent invocations safely, since the +// GIOP code is reentrant. +// +// = AUTHOR +// Copyright 1994-1995 by Sun Microsystems Inc., +// Chris Cleeland <cleeland@cs.wustl.edu> +// +// ============================================================================ + +#if !defined (TAO_GIOP_H) +# define TAO_GIOP_H + +// namespace TAO_IOP + +// Assigned Protocol/Profile tag values. ORB protcols may be +// uniquely identified by tags such as these. This allows each +// ORB's own objref profiles to be interchanged using IORs. +// +// Email to tag-request@omg.org to allocate tags. +typedef CORBA::ULong TAO_IOP_Profile_ID; + +enum +{ + TAO_IOP_TAG_INTERNET_IOP = 0, // IIOP + TAO_IOP_TAG_MULTIPLE_COMPONENTS = 1, // DCE-CIOP + + // This is a subset of the list of other profile tags. + TAO_IOP_TAG_ONC_IOP = 0x4f4e4300 // ONC IOP +}; + +struct TAO_IOP_Tagged_Profile +// One per protocol. +{ + TAO_IOP_Profile_ID tag; + TAO_opaque profile_data; +}; + +typedef TAO_Unbounded_Sequence<TAO_IOP_Tagged_Profile> TAO_IOP_Tagged_Profile_Sequence; + +struct TAO_IOP_IOR + // = TITLE + // InteroperableObjectReference + // + // = DESCRIPTION + // ... a set of protocol-specific protocol profiles, plus a type ID. + // Only one object is denoted by all of this information. It's OK + // to delete all profiles except the one for the single protocol + // actually being used. +{ + char *type_id; + TAO_IOP_Tagged_Profile_Sequence profiles; +}; + +// Some protocols can be factored into a set of optional components. +// Use of such components is defined by the protocol's specification. +// +// Email to tag-request@omg.org to allocate tags. + +typedef CORBA::ULong TAO_IOP_ComponentId; + +enum + // = DESCRIPTION + // These are all defined by DCE-CIOP in OMG TC document 95-3-10. +{ + TAO_IOP_TAG_DCE_STRING_BINDING = 100,// string binding handle + TAO_IOP_TAG_DCE_BINDING_NAME = 101, // CDS/GDS/... name + TAO_IOP_TAG_DCE_NO_PIPES = 102, // no component data + TAO_IOP_TAG_OBJECT_KEY = 10, // opaque + TAO_IOP_TAG_ENDPOINT_ID = 11, // uuid + TAO_IOP_TAG_LOCATION_POLICY = 12 // octet/enum +}; + +struct TAO_IOP_TaggedComponent + // = DESCRIPTION + // One way to represent multicomponent profiles, e.g. as done by the + // DCE-CIOP protocol. One of these gets encapsulated in + // Tagged_Profile::profile_data. TAG_MULTIPLE_COMPONENTS may be used + // to represent protocol profiles structured in that way, but + // protocol-specific tags facilitate simpler scanning of IORs since + // you can be assured that each profile only has data used within a + // single ORB protocol. +{ + TAO_IOP_ComponentId tag; + TAO_opaque component_data; +}; + +typedef TAO_Unbounded_Sequence<TAO_IOP_TaggedComponent> TAO_IOP_MultipleComponentProfile; + +// namespace TAO_GIOP + +struct TAO_Version +{ + CORBA::Octet major; + CORBA::Octet minor; +}; + +enum + // = DESCRIPTION + // GIOP protocol version 1.0 information. +{ + MY_MAJOR = 1, + MY_MINOR = 0 +}; + +enum TAO_GIOP_MsgType + // = DESCRIPTION + // All GIOP messages include a header and message type. +{ + // Not really a message type, but needed to bring that information + // back somehow + TAO_GIOP_EndOfFile = -1, // "discovered" by either + TAO_GIOP_Request = 0, // sent by client + TAO_GIOP_Reply = 1, // by server + TAO_GIOP_CancelRequest = 2, // by client + TAO_GIOP_LocateRequest = 3, // by client + TAO_GIOP_LocateReply = 4, // by server + TAO_GIOP_CloseConnection = 5, // by server + TAO_GIOP_MessageError = 6 // by both +}; + +struct TAO_GIOP_MessageHeader +{ + CORBA::Char magic [4]; // "GIOP" + TAO_Version giop_version; + CORBA::Octet byte_order; // 0 = big, 1 = little + CORBA::Octet message_type; // MsgType above + CORBA::ULong message_size; // in byte_order! +}; + +// defined by GIOP 1.0 protocol +// @@ Is this portable? The structure above could have some padding on +// machines with absurd padding requirements (like 8 byte boundaries); +// hence the size of it may not match th size of the header on the +// wire. +#define TAO_GIOP_HEADER_LEN sizeof (TAO_GIOP_MessageHeader) + +// Support for Implicit ORB Service Context +typedef CORBA::ULong TAO_GIOP_ServiceID; + +enum + // = TITLE + // Values for TAO_GIOP_ServiceID +{ + TAO_GIOP_TransactionService = 0 + + // More service IDs may be defined by OMG. + + // This is where our RIOP service ID will be defined... +}; + +struct TAO_GIOP_ServiceContext +{ + TAO_GIOP_ServiceID context_id; + TAO_opaque context_data; +}; + +typedef TAO_Unbounded_Sequence<TAO_GIOP_ServiceContext> TAO_GIOP_ServiceContextList; + +extern CORBA::TypeCode TC_ServiceContextList; + +// = Request, Reply headers + +class TAO_Export TAO_GIOP_RequestHeader + // = TITLE + // This class embodies the header of a GIOP request. + // + // = NOTES + // This used to be a <struct>, which is why everything is public. +{ +public: + TAO_GIOP_RequestHeader (void); + // Constructor. + + CORBA::Boolean init (CDR &msg, CORBA::Environment& env); + // Initialize the header from the values found in <msg>. + + //private: + TAO_GIOP_ServiceContextList service_info; + // The service context for the request (CORBA Reference?) + + CORBA::ULong request_id; + // Unique identifier for a request + + CORBA::Boolean response_expected; + // true if this request requires a response + + TAO_opaque object_key; + // The object key of the destination object. + + CORBA::String operation; + // Name of the operation being performed + + CORBA::Principal_ptr requesting_principal; + // Identifies the requester +}; + +enum TAO_GIOP_ReplyStatusType +{ + TAO_GIOP_NO_EXCEPTION, + // Request completed successfully + + TAO_GIOP_USER_EXCEPTION, + // Request terminated with user exception + + TAO_GIOP_SYSTEM_EXCEPTION, + // Request terminated with system exception + + TAO_GIOP_LOCATION_FORWARD + // @@ More info +}; + +struct TAO_GIOP_ReplyHeader +{ + TAO_GIOP_ServiceContextList service_info; + // Information + + CORBA::ULong request_id; + // Unique identifier of the request for which this is a reply + + TAO_GIOP_ReplyStatusType reply_status; + // Status of the reply (see above enum) +}; + +struct TAO_GIOP_CancelRequestHeader + // = DESCRIPTION + // Cancellation -- applies both to Requests and LocateRequests. +{ + CORBA::ULong request_id; + // Unique identifier of the request being cancelled +}; + +struct TAO_GIOP_LocateRequestHeader + // = DESCRIPTION + // Location service support +{ + TAO_GIOP_LocateRequestHeader (void); + // Constructor + + CORBA::Boolean init (CDR &msg, CORBA::Environment& env); + // Initialize the header from the values found in <msg>. + + CORBA::ULong request_id; + TAO_opaque object_key; +}; + +enum TAO_GIOP_LocateStatusType +{ + TAO_GIOP_UNKNOWN_OBJECT, + TAO_GIOP_OBJECT_HERE, + TAO_GIOP_OBJECT_FORWARD +}; + +struct TAO_GIOP_LocateReplyHeader +{ + CORBA::ULong request_id; + TAO_GIOP_LocateStatusType locate_status; +}; + +class TAO_Export TAO_GIOP_Invocation + // = TITLE + // Invocation: Sends a Request, optionally reads associated Reply. + // Uses transport info passed in, doesn't locate anything. + // + // = NOTES + // This should maybe be moved into its own file (invoke.h?) +{ +public: + TAO_GIOP_Invocation (IIOP_Object *data, + const char *operation, + CORBA::Boolean is_roundtrip); + + ~TAO_GIOP_Invocation (void); + + void start (CORBA::Environment &env); + // <start> goes beyond initialising data structures, and makes + // calls that may fail -- and thus throw exceptions. + + void put_param (CORBA::TypeCode_ptr tc, + void *value, + CORBA::Environment &env); + + TAO_GIOP_ReplyStatusType invoke (CORBA::ExceptionList &exceptions, + CORBA::Environment &env); + + void get_value (CORBA::TypeCode_ptr tc, + void *value, + CORBA::Environment &env); + // No CORBA::Context support (deprecated). + + CDR &stream (void); + // return the underlying stream + +private: + IIOP_Object *data_; + // The object on which this invocation is going. + + const char *opname_; + // Name of the operation being invoked. + + CORBA::Boolean do_rsvp_; + // Set to TRUE if this request a twoway. + + CORBA::ULong my_request_id_; + // Request ID of this operation. + + char buffer [CDR::DEFAULT_BUFSIZE]; + // Buffer used for CDR stream. + + CDR stream_; + // Stream into which the request is placed. + + TAO_Client_Connection_Handler *handler_; + // The handler for the client's connection. +}; + +class TAO_Export TAO_GIOP + // = TITLE + // A namespace for GIOP-related operations. + // + // = DESCRIPTION + // Only put static methods within this scope. +{ + ACE_CLASS_IS_NAMESPACE (TAO_GIOP); + +public: + // = Close a connection, first sending GIOP::CloseConnection + static void close_connection (TAO_Client_Connection_Handler *&handle, + void *ctx); + + static CORBA::Boolean start_message (TAO_GIOP_MsgType t, + CDR &msg); + // Build the header for a message of type <t> into stream <msg>. + + static CORBA::Boolean send_request (TAO_SVC_HANDLER *handler, + CDR &stream); + // Send message, returns TRUE if success, else FALSE. + + static TAO_GIOP_MsgType recv_request (TAO_SVC_HANDLER *&handler, + CDR &msg, + CORBA::Environment &env); + // Reads message, returns message type from header. + + static void make_error (CDR &msg, ...); + // Construct a message containing an error so that it can be sent as + // a response to a request. +}; + +#endif /* TAO_GIOP_H */ |