1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
// This may look like C, but it's really -*- C++ -*-
// -*- C++ -*-
// ===================================================================
/**
* @file IIOP_Transport.h
*
* $Id$
*
* @author Originally by Fred Kuhns <fredk@cs.wustl.edu>
* @author Modified by Balachandran Natarajan <bala@cs.wustl.edu>
*/
// ===================================================================
#ifndef TAO_IIOP_TRANSPORT_H
#define TAO_IIOP_TRANSPORT_H
#include "ace/pre.h"
#include "tao/Pluggable.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/SOCK_Stream.h"
#include "ace/Synch.h"
#include "ace/Svc_Handler.h"
#include "tao/IIOPC.h"
// Forward decls.
class TAO_IIOP_Connection_Handler;
class TAO_ORB_Core;
class TAO_Operation_Details;
class TAO_Pluggable_Messaging;
// Service Handler for this transport
typedef ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
TAO_IIOP_SVC_HANDLER;
/**
* @class TAO_IIOP_Transport
*
* @brief Specialization of the base TAO_Transport class to handle the
* IIOP protocol.
*
*
*
*/
class TAO_Export TAO_IIOP_Transport : public TAO_Transport
{
public:
/// Constructor.
TAO_IIOP_Transport (TAO_IIOP_Connection_Handler *handler,
TAO_ORB_Core *orb_core,
CORBA::Boolean flag);
/// Default destructor.
~TAO_IIOP_Transport (void);
/// Return the connection service handler
TAO_IIOP_SVC_HANDLER *service_handler (void);
/// The TAO_Transport methods, please check the documentation in
/// "tao/Pluggable.h" for more details.
virtual ACE_HANDLE handle (void);
virtual ACE_Event_Handler *event_handler (void);
virtual void close_connection (void);
virtual int idle (void);
/// Write the complete Message_Block chain to the connection.
virtual ssize_t send (TAO_Stub *stub,
int two_way,
const ACE_Message_Block *mblk,
const ACE_Time_Value *s = 0);
virtual ssize_t send (const ACE_Message_Block *mblk,
const ACE_Time_Value *s = 0,
size_t *bytes_transferred = 0);
/// Write the contents of the buffer of length len to the
/// connection.
virtual ssize_t send (const u_char *buf,
size_t len,
const ACE_Time_Value *s = 0);
/// Read len bytes from into buf.
virtual ssize_t recv (char *buf,
size_t len,
const ACE_Time_Value *s = 0);
/// Read and process the message from the connection. The processing
/// of the message is done by delegating the work to the underlying
/// messaging object
virtual int read_process_message (ACE_Time_Value *max_time_value = 0,
int block =0);
virtual int register_handler (void);
/// @@TODO: These methods IMHO should have more meaningful
/// names. The names seem to indicate nothing.
virtual int send_request (TAO_Stub *stub,
TAO_ORB_Core *orb_core,
TAO_OutputCDR &stream,
int twoway,
ACE_Time_Value *max_wait_time);
virtual int send_message (TAO_OutputCDR &stream,
TAO_Stub *stub = 0,
int twoway = 1,
ACE_Time_Value *max_time_wait = 0);
virtual void start_request (TAO_ORB_Core *orb_core,
TAO_Target_Specification &spec,
TAO_OutputCDR &output,
CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ())
ACE_THROW_SPEC ((CORBA::SystemException));
virtual void start_locate (TAO_ORB_Core *orb_core,
TAO_Target_Specification &spec,
TAO_Operation_Details &opdetails,
TAO_OutputCDR &output,
CORBA::Environment &ACE_TRY_ENV = TAO_default_environment ())
ACE_THROW_SPEC ((CORBA::SystemException));
virtual CORBA::Boolean
send_request_header (TAO_Operation_Details &opdetails,
TAO_Target_Specification &spec,
TAO_OutputCDR &msg);
/// Initialising the messaging object
virtual int messaging_init (CORBA::Octet major,
CORBA::Octet minor);
/// Set the bidirectional flag
virtual void bidirectional_flag (int flag);
/// Open teh service context list and process it.
virtual int tear_listen_point_list (TAO_InputCDR &cdr);
private:
/// Process the message that we have read
int process_message (void);
/// Set the Bidirectional context info in the service context list
void set_bidir_context_info (TAO_Operation_Details &opdetails);
/// Add the listen points in <acceptor> to the <listen_point_list>
/// if this connection is in the same interface as that of the
/// endpoints in the <acceptor>
int get_listen_point (IIOP::ListenPointList &listen_point_list,
TAO_Acceptor *acceptor);
private:
/// The connection service handler used for accessing lower layer
/// communication protocols.
TAO_IIOP_Connection_Handler *connection_handler_;
/// Our messaging object.
TAO_Pluggable_Messaging *messaging_object_;
/// Have we sent any info on bidirectional information or have we
/// received any info regarding making the connection
/// served by this transport bidirectional. This is essentially for
/// this -- we dont want to send the bidirectional context info more
/// than once on the connection. Why? Waste of marshalling and
/// demarshalling time on the client. On the server side, we need
/// this flag for this -- once a client that has established the
/// connection asks the server to use the connection both ways, we
/// *dont* want the server to go pack service info to the
/// client. That would be *bad*.. The value of this flag will be 0
/// if the client sends info and 1 if the server receives the info.
int bidirectional_flag_;
};
#if defined (__ACE_INLINE__)
#include "tao/IIOP_Transport.i"
#endif /* __ACE_INLINE__ */
#include "ace/post.h"
#endif /* TAO_IIOP_TRANSPORT_H */
|
