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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
|
// @ (#)orbobj.cpp 1.8 95/09/24
// Copyright 1994-1995 by Sun Microsystems Inc.
// All Rights Reserved
//
// ORB: CORBA::ORB operations
//
// XXX as with TAO, this has a strong coupling to the Internet ORB
// (IIOP) code. We should make it know less about that protocol
// component and have a loose table-driven coupling to ORB/protocol
// library components.
#include <assert.h>
#include <limits.h>
#include <signal.h>
#include <string.h>
#include "orb.h"
#include "stub.h"
#include "debug.h"
#include "iioporb.h" // XXX
#include "params.h"
#include "boa.h"
#include "roa.h"
#include <initguid.h>
extern void __TC_init_table (void);
extern void __TC_init_standard_exceptions (CORBA_Environment &env);
#if defined (SIG_IGN_BROKEN)
# undef SIG_IGN
# define SIG_IGN ((RETSIGTYPE (*) (int))1)
#endif // NeXT
// COM's IUnknown support
// {A201E4C6-F258-11ce-9598-0000C07CA898}
DEFINE_GUID (IID_CORBA_ORB,
0xa201e4c6, 0xf258, 0x11ce, 0x95, 0x98, 0x0, 0x0, 0xc0, 0x7c, 0xa8, 0x98);
#if 0
// {A201E4C7-F258-11ce-9598-0000C07CA898}
DEFINE_GUID (IID_STUB_Object,
0xa201e4c7, 0xf258, 0x11ce, 0x95, 0x98, 0x0, 0x0, 0xc0, 0x7c, 0xa8, 0x98);
#endif
ULONG __stdcall
CORBA_ORB::Release (void)
{
ACE_GUARD_RETURN (ACE_Thread_Mutex, guard, lock_, 0);
assert (this != 0);
if (--_refcount != 0)
return _refcount;
guard.release ();
delete this;
return 0;
}
// ORB initialisation, per OMG document 94-9-46.
//
// XXX in addition to the "built in" Internet ORB, there will be ORBs
// which are added separately, e.g. through a DLL listed in the
// registry. Registry will be used to assign orb names and to
// establish which is the default.
CORBA_ORB_ptr
CORBA_ORB_init (int &argc,
char *const *argv,
char *orb_name,
CORBA_Environment &env)
{
static ACE_Thread_Mutex lock;
ACE_GUARD_RETURN (ACE_Thread_Mutex, guard, lock, 0);
env.clear ();
// Verify some of the basic implementation requirements. This test
// gets optimized away by a decent compiler (or else the rest of the
// routine does).
//
// NOTE: we still "just" assume that native floating point is IEEE.
if (sizeof (CORBA_Short) != 2
|| sizeof (CORBA_Long) != 4
|| sizeof (CORBA_LongLong) != 8
|| sizeof (CORBA_Float) != 4
|| sizeof (CORBA_Double) != 8
|| sizeof (CORBA_LongDouble) != 16
|| sizeof (CORBA_WChar) < 2
|| sizeof (void *) != SIZEOF_VOID_P)
{
env.exception (new CORBA_INITIALIZE (COMPLETED_NO));
return 0;
}
// ignoring argc, argv for now -- no arguments we care about
//
// XXX should remove any of the "-ORB*" arguments that we know about
// ... and report errors for the rest.
//
// Parsing of these arguments should set values in a
// TAO_ORB_Parameters instance, likely the one contained in the
// newly-created ORB.
#ifdef DEBUG
// Make it a little easier to debug programs using this code.
{
char *value = ACE_OS::getenv ("TAO_ORB_DEBUG");
if (value != 0)
{
TAO_debug_level = ACE_OS::atoi (value);
if (TAO_debug_level <= 0)
TAO_debug_level = 1;
dmsg1 ("TAO_debug_level == %d", TAO_debug_level);
}
}
#endif /* DEBUG */
// On Win32, we should be collecting information from the Registry
// such as what ORBs are configured, specific configuration details
// like whether they generate IOR or URL style stringified objrefs
// and which addresses they listen to (e.g. allowing multihomed
// hosts to implement firewalls), user-meaningful orb names (they
// will normally indicate domains), and more.
//
// On UNIX, we should collect that from some private config file.
//
// Instead, this just treats the "internet" ORB name specially and
// makes it always use URL-style stringified objrefs, where the
// hostname and TCP port number are explicit (and the whole objref
// is readable by mortals).
CORBA_Boolean use_ior;
if (orb_name != 0 && ACE_OS::strcmp (orb_name, "internet") == 0)
use_ior = CORBA_B_FALSE;
else
use_ior = CORBA_B_TRUE;
#ifdef SIGPIPE
// @@ Is there a better way to deal with this in a portable manner? --cjc
//
// Impractical to have each call to the ORB protect against the
// implementation artifact of potential writes to dead connections,
// as it'd be way expensive. Do it here; who cares about SIGPIPE in
// these kinds of applications, anyway?
(void) ACE_OS::signal (SIGPIPE, SIG_IGN);
#endif // SIGPIPE
ACE_OS::socket_init (ACE_WSOCK_VERSION);
// Call various internal initialization routines.
__TC_init_table ();
__TC_init_standard_exceptions (env);
if (env.exception () != 0)
return 0;
// Inititalize the "ORB" pseudo-object now.
IIOP_ORB_ptr the_orb = TAO_ORB::instance ();
the_orb->use_omg_ior_format (CORBA_Boolean(use_ior));
return the_orb;
}
void
CORBA_ORB::create_list (CORBA_Long count,
CORBA_NVList_ptr &retval)
{
assert (count <= UINT_MAX);
retval = new CORBA_NVList;
if (count != 0) {
retval->_len = 0;
retval->_max = (u_int) count;
retval->_values = (CORBA_NamedValue_ptr) ACE_OS::calloc ((u_int) count,
sizeof (CORBA_NamedValue));
}
}
// This is a server-side internal routine; it's not available to any
// portable code except method code, which moreover may not access the
// state variable directly since its implemention may differ between
// ORBs.
//
// XXX it's server-side so should be OA-specific and not in this module
CORBA_ORB_ptr
_orb (void)
{
return TAO_ORB::instance();
}
CORBA_BOA_ptr CORBA_ORB::BOA_init (int &argc,
char **argv,
const char *boa_identifier)
{
// parse the arguments looking for options starting with -OA. After
// processing these options, move all these to the end of the argv
// list and decrement argc appropriately.
TAO_OA_Parameters *params = TAO_OA_PARAMS::instance (); //should have been BOA_Parameters
CORBA_BOA_ptr rp;
CORBA_String_var id = boa_identifier;
CORBA_String_var host = CORBA_string_dup ("");
CORBA_String_var demux = CORBA_string_dup ("dynamic_hash"); // default atleast for now
CORBA_UShort port = 5001; // some default port -- needs to be a #defined value
CORBA_ULong tablesize = 0; // default table size for lookup tables
CORBA_Boolean numeric = CORBA_B_FALSE;
CORBA_Boolean use_threads = CORBA_B_FALSE;
const char *ior = 0;
ACE_INET_Addr rendezvous;
CORBA_Environment env;
int i = 0;
while (i < argc)
{
// @@ Can you please add comments describing each of these options? --doug
// @@ Andy, could you review these since you wrote the code --cjc
if (ACE_OS::strcmp (argv[i], "-OAid") == 0)
{
// Specify the name of the OA
if (i + 1 < argc)
id = CORBA_string_dup (argv[i + 1]);
for (int j = i ; j + 2 < argc ; j++)
argv[j] = argv[j + 2];
argc -= 2;
}
else if (ACE_OS::strcmp (argv[i], "-OAhost") == 0)
{
// Specify the name of the host (i.e., interface) on which
// the server should listen
if (i + 1 < argc)
host = CORBA_string_dup (argv[i + 1]);
for (int j = i ; j + 2 < argc ; j++)
argv[j] = argv[j + 2];
argc -= 2;
}
else if (ACE_OS::strcmp (argv[i], "-OAport") == 0)
{
// Specify the port number/name on which we should listen
if (i + 1 < argc)
// @@ We shouldn't limit this to being specified as an int! --cjc
port = ACE_OS::atoi (argv[i + 1]);
for (int j = i ; j + 2 < argc ; j++)
argv[j] = argv[j + 2];
argc -= 2;
}
else if (ACE_OS::strcmp (argv[i], "-OAobjdemux") == 0)
{
// Specify the demultiplexing strategy to be used for object demultiplexing
if (i + 1 < argc)
demux = CORBA_string_dup (argv[i+1]);
for (int j = i ; j + 2 < argc ; j++)
argv[j] = argv[j + 2];
argc -= 2;
}
else if (ACE_OS::strcmp (argv[i], "-OAtablesize") == 0)
{
// @@ Specify the table size used for ????
if (i + 1 < argc)
tablesize = ACE_OS::atoi (argv[i+1]);
for (int j = i ; j + 2 < argc ; j++)
argv[j] = argv[j + 2];
argc -= 2;
}
else if (ACE_OS::strcmp (argv[i], "-OArcvsock") == 0)
{
// Specify the size of the socket's receive buffer
}
else if (ACE_OS::strcmp (argv[i], "-OAsndsock") == 0)
{
// Specify the size of the socket's send buffer
}
else if (ACE_OS::strcmp (argv[i], "-OAthread") == 0)
{
// Specify whether or not threads should be used.
use_threads = CORBA_B_TRUE;
for (int j = i ; j + 1 < argc ; j++)
argv[j] = argv[j + 1];
argc -= 1;
}
else
i++;
}
// create a INET_Addr
if (ACE_OS::strlen (host) > 0)
rendezvous.set (port, host);
else
rendezvous.set (port);
// ACE_MT (ACE_GUARD (ACE_Thread_Mutex, roa_mon, lock_));
if (params->oa ())
{
env.exception (new CORBA_INITIALIZE (COMPLETED_NO));
return 0;
}
// set all parameters
params->using_threads (use_threads);
params->demux_strategy (demux);
params->addr (rendezvous);
params->upcall (CORBA_BOA::dispatch);
params->tablesize (tablesize);
#if defined (ROA_NEED_REQ_KEY)
(void) ACE_Thread::keycreate (&req_key_);
#endif
ACE_NEW_RETURN (rp, ROA (this, env), 0);
return rp;
}
#if !defined (__ACE_INLINE__)
# include "orbobj.i"
#endif
|