← Back to branch summary

~ubuntu-branches/ubuntu/breezy/orbit2/breezy

« back to all changes in this revision

Viewing changes to src/orb/orb-core/corba-orb.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-09-06 16:37:02 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050906163702-hrqi0ctymth53bnn
Tags: 1:2.12.4-0ubuntu1
* New upstream version.
* debian/patches/100-compile-name-server.patch:
  - updated.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/orb/orb-core/corba-orb.c
 
1
 
1
2
#include <config.h>
2
3
#include <ctype.h>
3
4
#include <string.h>
4
 
#include <popt.h>
5
5
 
6
6
#include <orbit/orbit.h>
7
7
 
11
11
#include "../util/orbit-purify.h"
12
12
#include "iop-profiles.h"
13
13
#include "orb-core-private.h"
 
14
#if defined ENABLE_HTTP
14
15
#include "orbhttp.h"
 
16
#endif
15
17
#include "orbit-debug.h"
16
18
 
17
 
extern ORBit_option orbit_supported_options[];
 
19
extern const ORBit_option orbit_supported_options[];
18
20
 
19
21
#ifdef G_ENABLE_DEBUG
20
22
OrbitDebugFlags _orbit_debug_flags = ORBIT_DEBUG_NONE;
23
25
/*
24
26
 * Command line option handling.
25
27
 */
26
 
static gboolean     orbit_use_ipv4          = FALSE;
27
 
static gboolean     orbit_use_ipv6          = FALSE; 
28
 
static gboolean     orbit_use_usocks        = TRUE;
29
 
static gboolean     orbit_use_irda          = FALSE;
30
 
static gboolean     orbit_use_ssl           = FALSE;
31
 
static gboolean     orbit_use_genuid_simple = FALSE;
32
 
static char        *orbit_ipsock            = NULL;
33
 
static char        *orbit_ipname            = NULL;
34
 
static char        *orbit_debug_options     = NULL;
 
28
#ifdef G_OS_WIN32
 
29
static gboolean     orbit_use_ipv4           = TRUE;
 
30
#else
 
31
static gboolean     orbit_use_ipv4           = FALSE;
 
32
#endif
 
33
static gboolean     orbit_use_ipv6           = FALSE; 
 
34
#ifdef G_OS_WIN32
 
35
static gboolean     orbit_use_usocks         = FALSE;
 
36
#else
 
37
static gboolean     orbit_use_usocks         = TRUE;
 
38
#endif
 
39
static gint         orbit_initial_recv_limit = -1;
 
40
static gboolean     orbit_use_irda           = FALSE;
 
41
static gboolean     orbit_use_ssl            = FALSE;
 
42
static gboolean     orbit_use_genuid_simple  = FALSE;
 
43
static gboolean     orbit_local_only         = FALSE;
 
44
static gboolean     orbit_use_http_iors      = FALSE;
 
45
static char        *orbit_ipsock             = NULL;
 
46
static char        *orbit_ipname             = NULL;
 
47
static char        *orbit_debug_options      = NULL;
 
48
static char        *orbit_naming_ref         = NULL;
 
49
static GSList      *orbit_initref_list       = NULL; 
 
50
static gboolean     orbit_use_corbaloc       = FALSE;
35
51
 
36
52
void
37
53
ORBit_ORB_start_servers (CORBA_ORB orb)
38
54
{
39
 
        LINCProtocolInfo *info;
40
 
 
41
 
        for (info = linc_protocol_all (); info->name; info++) {
 
55
        LinkProtocolInfo     *info;
 
56
        LinkConnectionOptions create_options = 0;
 
57
 
 
58
        LINK_MUTEX_LOCK (orb->lock);
 
59
        
 
60
        if (orb->servers) { /* beaten to it */
 
61
                LINK_MUTEX_UNLOCK (orb->lock);
 
62
                return;
 
63
        }
 
64
 
 
65
        if (orbit_local_only)
 
66
                create_options |= LINK_CONNECTION_LOCAL_ONLY;
 
67
 
 
68
        if (orbit_local_only || (orbit_use_usocks && !(orbit_use_ipv4 || orbit_use_ipv6 || orbit_use_irda || orbit_use_ssl)))
 
69
                        link_use_local_hostname (TRUE);
 
70
 
 
71
        for (info = link_protocol_all (); info->name; info++) {
42
72
                GIOPServer           *server;
43
73
 
44
74
                if (!ORBit_proto_use (info->name))
45
75
                        continue;
46
76
 
47
 
                server = giop_server_new (orb->default_giop_version,
48
 
                                          info->name, orbit_ipname,
49
 
                                          orbit_ipsock, 0, orb);
 
77
                server = giop_server_new (
 
78
                        orb->default_giop_version, info->name,
 
79
                        orbit_ipname, orbit_ipsock,
 
80
                        create_options, orb);
 
81
 
50
82
                if (server) {
51
83
                        orb->servers = g_slist_prepend (orb->servers, server);
52
84
 
53
 
                        if (!(info->flags & LINC_PROTOCOL_SECURE)) {
 
85
                        if (!(info->flags & LINK_PROTOCOL_SECURE)) {
54
86
                                if (!ORBit_proto_use ("SSL"))
55
87
                                        continue;
56
88
 
57
89
                                server = giop_server_new (
58
90
                                        orb->default_giop_version, info->name,
59
 
                                        NULL, NULL, LINC_CONNECTION_SSL, orb);
 
91
                                        NULL, NULL, LINK_CONNECTION_SSL | create_options,
 
92
                                        orb);
60
93
 
61
94
                                if (server)
62
95
                                        orb->servers = g_slist_prepend (orb->servers, server);
72
105
        }
73
106
 
74
107
        orb->profiles = IOP_start_profiles (orb);
 
108
 
 
109
        LINK_MUTEX_UNLOCK (orb->lock);
 
110
}
 
111
 
 
112
static void
 
113
strip_object_profiles (gpointer o, gpointer b, gpointer c)
 
114
{
 
115
        CORBA_Object obj = o;
 
116
        IOP_delete_profiles (obj->orb, &obj->profile_list);
 
117
        IOP_delete_profiles (obj->orb, &obj->forward_locations);
75
118
}
76
119
 
77
120
static void
78
121
ORBit_ORB_shutdown_servers (CORBA_ORB orb)
79
122
{
 
123
        LINK_MUTEX_LOCK (orb->lock);
 
124
 
 
125
        if (orb->objrefs) {
 
126
                g_hash_table_foreach (orb->objrefs,
 
127
                                      strip_object_profiles, NULL);
 
128
                g_hash_table_destroy (orb->objrefs);
 
129
                orb->objrefs = NULL;
 
130
        }
 
131
 
80
132
        IOP_shutdown_profiles (orb->profiles);
81
133
        orb->profiles = NULL;
82
134
 
83
135
        g_slist_foreach (orb->servers, (GFunc) g_object_unref, NULL);
84
136
        g_slist_free (orb->servers); 
85
137
        orb->servers = NULL;
 
138
 
 
139
        LINK_MUTEX_UNLOCK (orb->lock);
86
140
}
87
141
 
88
142
static ORBitGenUidType
101
155
}
102
156
 
103
157
static void
 
158
genuid_init (void)
 
159
{
 
160
        /* We treat the 'local_only' mode as a very special case */
 
161
        if (orbit_local_only &&
 
162
            orbit_use_genuid_simple)
 
163
                g_error  ("It is impossible to isolate one user from another "
 
164
                          "with only simple cookie generation, you cannot "
 
165
                          "explicitely enable this option and LocalOnly mode "
 
166
                          "at the same time");
 
167
 
 
168
        else if (!ORBit_genuid_init (ORBit_genuid_type ())) {
 
169
 
 
170
                if (orbit_local_only)
 
171
                        g_error ("Failed to find a source of randomness good "
 
172
                                 "enough to insulate local users from each "
 
173
                                 "other. If you use Solaris you need /dev/random "
 
174
                                 "from the SUNWski package");
 
175
        }
 
176
}
 
177
 
 
178
 
 
179
static void
104
180
ORBit_service_list_free_ref (gpointer         key,
105
181
                             ORBit_RootObject objref,
106
182
                             gpointer         dummy)
125
201
static void
126
202
ORBit_locks_initialize (void)
127
203
{
128
 
        ORBit_RootObject_lifecycle_lock = linc_mutex_new ();
 
204
        ORBit_RootObject_lifecycle_lock = link_mutex_new ();
129
205
}
130
206
 
131
207
#ifdef G_ENABLE_DEBUG
133
209
ORBit_setup_debug_flags (void)
134
210
{
135
211
        static GDebugKey debug_keys[] = {
136
 
                { "traces",   ORBIT_DEBUG_TRACES },
137
 
                { "timings",  ORBIT_DEBUG_TIMINGS },
138
 
                { "types",    ORBIT_DEBUG_TYPES },
139
 
                { "messages", ORBIT_DEBUG_MESSAGES },
140
 
                { "objects",  ORBIT_DEBUG_OBJECTS },
141
 
                { "giop",     ORBIT_DEBUG_GIOP },
142
 
                { "refs",     ORBIT_DEBUG_REFS },
 
212
                { "traces",         ORBIT_DEBUG_TRACES },
 
213
                { "inproc_traces",  ORBIT_DEBUG_INPROC_TRACES },
 
214
                { "timings",        ORBIT_DEBUG_TIMINGS },
 
215
                { "types",          ORBIT_DEBUG_TYPES },
 
216
                { "messages",       ORBIT_DEBUG_MESSAGES },
 
217
                { "errors",         ORBIT_DEBUG_ERRORS },
 
218
                { "objects",        ORBIT_DEBUG_OBJECTS },
 
219
                { "giop",           ORBIT_DEBUG_GIOP },
 
220
                { "refs",           ORBIT_DEBUG_REFS },
 
221
                { "force_threaded", ORBIT_DEBUG_FORCE_THREADED }
143
222
        };
144
223
        const char *env_string;
145
224
 
156
235
                        g_parse_debug_string (orbit_debug_options,
157
236
                                              debug_keys,
158
237
                                              G_N_ELEMENTS (debug_keys));
 
238
 
 
239
        if (_orbit_debug_flags & ORBIT_DEBUG_INPROC_TRACES)
 
240
                ORBit_small_flags |= ORBIT_SMALL_FORCE_GENERIC_MARSHAL;
159
241
}
160
242
#endif /* G_ENABLE_DEBUG */
161
243
 
162
244
static CORBA_ORB _ORBit_orb = NULL;
163
245
static gulong    init_level = 0;
 
246
static gboolean  atexit_shutdown = FALSE;
 
247
 
 
248
/*
 
249
 *   This is neccessary to clean up any remaining UDS
 
250
 * and to flush any remaining oneway traffic in buffers.
 
251
 */
 
252
static void
 
253
shutdown_orb (void)
 
254
{
 
255
        CORBA_ORB orb;
 
256
        CORBA_Environment ev;
 
257
 
 
258
        if (!(orb = _ORBit_orb))
 
259
                return;
 
260
 
 
261
        init_level = 1; /* clobber it */
 
262
        atexit_shutdown = TRUE;
 
263
        
 
264
        CORBA_exception_init (&ev);
 
265
 
 
266
        CORBA_ORB_destroy (orb, &ev);
 
267
        ORBit_RootObject_release (orb);
 
268
 
 
269
        CORBA_exception_free (&ev);
 
270
 
 
271
        atexit_shutdown = FALSE;
 
272
}
 
273
 
 
274
static
 
275
gboolean
 
276
ORBit_initial_reference_protected_id (gchar* id)
 
277
{
 
278
        return (!strncmp (id, "RootPOA", strlen("RootPOA")) ||
 
279
                !strncmp (id, "POACurrent", strlen("POACurrent")));
 
280
}
 
281
  
 
282
static void 
 
283
ORBit_initial_references_by_user (CORBA_ORB          orb, 
 
284
                                  gchar             *naming_ref,
 
285
                                  GSList            *initref_list,
 
286
                                  CORBA_Environment *ev)
 
287
{
 
288
        GSList *l;
 
289
        CORBA_Object objref;
 
290
 
 
291
        if (ev->_major != CORBA_NO_EXCEPTION)
 
292
                return;
 
293
 
 
294
        if (naming_ref) {
 
295
                objref = CORBA_ORB_string_to_object (orb, naming_ref, ev);
 
296
                
 
297
                /* FIXME, should abort if invalid option, don't forget
 
298
                 * to free resources allocated by ORB */ 
 
299
                if (ev->_major != CORBA_NO_EXCEPTION) {
 
300
                        g_warning ("Option ORBNamingIOR has invalid object reference: %s", 
 
301
                                   naming_ref);
 
302
                        CORBA_exception_free (ev);
 
303
                } else {
 
304
                        /* FIXME, test type of object for
 
305
                         * IDL:omg.org/CosNaming/NamingContext using _is_a()
 
306
                         * operation */ 
 
307
                        ORBit_set_initial_reference (orb, "NameService", objref);
 
308
                        ORBit_RootObject_release (objref);
 
309
                }
 
310
        }
 
311
 
 
312
        for (l = initref_list; l; l = l->next) {
 
313
                ORBit_OptionKeyValue *tuple = l->data;
 
314
 
 
315
                g_assert (tuple != NULL);
 
316
                g_assert (tuple->key   != (gchar*)NULL);
 
317
                g_assert (tuple->value != (gchar*)NULL);
 
318
                        
 
319
                objref = CORBA_ORB_string_to_object (orb, tuple->value, ev);
 
320
 
 
321
                /* FIXME, should abort if invalid option,
 
322
                 * don't forget to free resources allocated by
 
323
                 * ORB */ 
 
324
                if (ev->_major != CORBA_NO_EXCEPTION) {
 
325
                        g_warning ("Option ORBInitRef has invalid object reference: %s=%s",  
 
326
                                   tuple->key, tuple->value);
 
327
                        CORBA_exception_free (ev);
 
328
                } else {
 
329
                        if (ORBit_initial_reference_protected_id(tuple->key)) {
 
330
                                g_warning ("Option ORBInitRef permission denied: %s=%s",
 
331
                                           tuple->key, tuple->value);
 
332
                        } else {
 
333
                                ORBit_set_initial_reference (orb, tuple->key, objref);
 
334
                        }
 
335
                        
 
336
                        ORBit_RootObject_release (objref);
 
337
                }
 
338
        }
 
339
 
 
340
}
164
341
 
165
342
CORBA_ORB
166
343
CORBA_ORB_init (int *argc, char **argv,
167
344
                CORBA_ORBid orb_identifier,
168
345
                CORBA_Environment *ev)
169
346
{
 
347
        gboolean thread_safe;
170
348
        CORBA_ORB retval;
171
349
        static ORBit_RootObject_Interface orb_if = {
172
350
                ORBIT_ROT_ORB,
181
359
        /* the allocation code uses the bottom bit of any pointer */
182
360
        g_assert (ORBIT_ALIGNOF_CORBA_DOUBLE > 2);
183
361
 
 
362
        if (orb_identifier &&
 
363
            strstr (orb_identifier, "orbit-local-non-threaded-orb") != NULL)
 
364
                thread_safe = FALSE;
 
365
        else
 
366
                thread_safe = TRUE;
 
367
 
184
368
        ORBit_option_parse (argc, argv, orbit_supported_options);
185
 
 
 
369
        
186
370
#ifdef G_ENABLE_DEBUG
187
371
        ORBit_setup_debug_flags ();
 
372
 
 
373
        if (_orbit_debug_flags & ORBIT_DEBUG_FORCE_THREADED) {
 
374
                g_warning ("-- Forced orb into threaded mode --");
 
375
                thread_safe |= TRUE;
 
376
        }
188
377
#endif /* G_ENABLE_DEBUG */
189
378
 
190
 
        giop_init ();
 
379
 
 
380
        giop_recv_set_limit (orbit_initial_recv_limit);
 
381
        giop_init (thread_safe,
 
382
                   orbit_use_ipv4 || orbit_use_ipv6 ||
 
383
                   orbit_use_irda || orbit_use_ssl);
 
384
 
 
385
        if (orb_identifier && thread_safe &&
 
386
            strstr (orb_identifier, "orbit-io-thread") != NULL)
 
387
                link_set_io_thread (TRUE);
 
388
 
 
389
        genuid_init ();
 
390
        _ORBit_object_init ();
 
391
        ORBit_poa_init ();
191
392
 
192
393
        ORBit_locks_initialize ();
193
394
 
196
397
        ORBit_RootObject_init (&retval->root_object, &orb_if);
197
398
        /* released by CORBA_ORB_destroy */
198
399
        _ORBit_orb = ORBit_RootObject_duplicate (retval);
 
400
        _ORBit_orb->lock = link_mutex_new ();
 
401
        g_atexit (shutdown_orb);
199
402
 
200
 
        ORBit_genuid_init (ORBit_genuid_type ());
201
403
        retval->default_giop_version = GIOP_LATEST;
202
404
 
203
405
        retval->adaptors = g_ptr_array_new ();
204
406
        ORBit_init_internals (retval, ev);
 
407
        /* FIXME, handle exceptions */ 
 
408
 
 
409
        ORBit_initial_references_by_user (retval, 
 
410
                                          orbit_naming_ref,
 
411
                                          orbit_initref_list,
 
412
                                          ev);
 
413
        /* FIXME, handle exceptions */ 
205
414
 
206
415
        return ORBit_RootObject_duplicate (retval);
207
416
}
208
417
 
209
418
CORBA_char *
210
419
CORBA_ORB_object_to_string (CORBA_ORB          orb,
211
 
                           const CORBA_Object  obj,
212
 
                           CORBA_Environment  *ev)
 
420
                            const CORBA_Object obj,
 
421
                            CORBA_Environment *ev)
213
422
{
214
423
        GIOPSendBuffer *buf;
215
424
        CORBA_octet     endianness = GIOP_FLAG_ENDIANNESS;
225
434
                return NULL;
226
435
        }
227
436
 
 
437
        if (orbit_use_corbaloc) {
 
438
                out = ORBit_object_to_corbaloc (obj, ev);
 
439
                if (ev->_major == CORBA_NO_EXCEPTION)
 
440
                        return out;
 
441
 
 
442
                CORBA_exception_free (ev);      
 
443
                /* fall thru, common marshalling */ 
 
444
        }
 
445
        
228
446
        buf = giop_send_buffer_use (orb->default_giop_version);
229
447
 
230
448
        g_assert (buf->num_used == 1);
278
496
        guchar              *tmpbuf;
279
497
        int                  i;
280
498
 
281
 
        if (strncmp (string, "IOR:", 4)) {
282
 
                if (strstr (string, "://")) {
 
499
        if (strncmp (string, "IOR:", strlen("IOR:"))            &&
 
500
            strncmp (string, "corbaloc:", strlen ("corbaloc:")) &&
 
501
            strncmp (string, "iiop:", strlen ("iiop:"))         &&
 
502
            strncmp (string, "iiops:", strlen ("iiops:"))       &&
 
503
            strncmp (string, "ssliop:", strlen ("ssliop:"))     &&
 
504
            strncmp (string, "uiop:", strlen ("uiop:"))) {
 
505
 
 
506
#if defined ENABLE_HTTP
 
507
                if (orbit_use_http_iors &&
 
508
                    strstr (string, "://")) {
 
509
                        /* FIXME: this code is a security hazard */
283
510
                        ior = orb_http_resolve (string);
284
511
                        if (!ior)
285
512
                                return CORBA_OBJECT_NIL;
286
513
 
287
514
                        string = ior;
288
 
                } else {
 
515
                } else 
 
516
#endif
 
517
                {
289
518
                        CORBA_exception_set_system (
290
519
                                        ev,
291
520
                                        ex_CORBA_BAD_PARAM,
295
524
                }
296
525
        }
297
526
 
298
 
        string += 4;
299
 
        len = strlen (string);
300
 
        while (len > 0 && !g_ascii_isxdigit (string [len - 1]))
301
 
                len--;
302
 
 
303
 
        if (len % 2) {
304
 
                if (ior)
305
 
                        g_free (ior);
306
 
 
307
 
                return CORBA_OBJECT_NIL;
308
 
        }
309
 
 
310
 
        tmpbuf = g_alloca (len / 2);
311
 
 
312
 
        for (i = 0; i < len; i += 2)
313
 
                tmpbuf [i/2] = (g_ascii_xdigit_value (string [i]) << 4) |
314
 
                                        g_ascii_xdigit_value (string [i + 1]);
315
 
 
316
 
        buf = giop_recv_buffer_use_encaps (tmpbuf, len / 2);
317
 
 
318
 
        if (ORBit_demarshal_object (&retval, buf, orb)) {
319
 
                CORBA_exception_set_system (
 
527
        if (!strncmp (string, "IOR:", strlen ("IOR:")))
 
528
        {
 
529
                string += 4;
 
530
                len = strlen (string);
 
531
                while (len > 0 && !g_ascii_isxdigit (string [len - 1]))
 
532
                        len--;
 
533
                
 
534
                if (len % 2) {
 
535
                        if (ior)
 
536
                                g_free (ior);
 
537
                        
 
538
                        return CORBA_OBJECT_NIL;
 
539
                }
 
540
                
 
541
                tmpbuf = g_alloca (len / 2);
 
542
                
 
543
                for (i = 0; i < len; i += 2)
 
544
                        tmpbuf [i/2] = (g_ascii_xdigit_value (string [i]) << 4) |
 
545
                                g_ascii_xdigit_value (string [i + 1]);
 
546
                
 
547
                buf = giop_recv_buffer_use_encaps (tmpbuf, len / 2);
 
548
                
 
549
                if (ORBit_demarshal_object (&retval, buf, orb)) {
 
550
                        CORBA_exception_set_system (
320
551
                                ev,
321
552
                                ex_CORBA_MARSHAL,
322
553
                                CORBA_COMPLETED_NO);
323
 
 
324
 
                retval = CORBA_OBJECT_NIL;
325
 
        }
326
 
 
327
 
        giop_recv_buffer_unuse (buf);
328
 
 
329
 
        if (ior)
330
 
                g_free (ior);
331
 
 
332
 
        return retval;
 
554
                        
 
555
                        retval = CORBA_OBJECT_NIL;
 
556
                }
 
557
                
 
558
                giop_recv_buffer_unuse (buf);
 
559
                
 
560
                if (ior)
 
561
                        g_free (ior);
 
562
                
 
563
                return retval;
 
564
        } else {
 
565
                return ORBit_object_by_corbaloc (orb, string, ev);
 
566
        } 
333
567
}
334
568
 
335
569
void
390
624
                                   CORBA_ServiceInformation **service_information,
391
625
                                   CORBA_Environment         *ev)
392
626
{
 
627
        /* FIXME: 
 
628
         * see http://mail.gnome.org/archives/orbit-list/2003-May/msg00093.html
 
629
 
 
630
         * Assigning NULL to parameter service_information is not
 
631
         * compliant to CORBA spec. This operation is part of pseudo
 
632
         * interface and must react like operation of true remote
 
633
         * interface. The question is what value it should point to in
 
634
         * case CORBA_FALSE is returned to caller.
 
635
 
 
636
         4.2.2 Getting Service Information
 
637
         4.2.2.1 get_service_information
 
638
 
 
639
         boolean get_service_information (in ServiceType service_type;
 
640
                                          out ServiceInformation service_information;);
 
641
 
 
642
         * The get_service_information operation is used to obtain
 
643
         * information about CORBA facilities and services that are
 
644
         * supported by this ORB. The service type for which
 
645
         * information is being requested is passed in as the in
 
646
         * parameter service_type, the values defined by constants in
 
647
         * the CORBA module. If service information is available for
 
648
         * that type, that is returned in the out parameter
 
649
         * service_information, and the operation returns the value
 
650
         * TRUE. If no information for the requested services type is
 
651
         * available, the operation returns FALSE (i.e., the service
 
652
         * is not supported by this ORB).
 
653
         */     
393
654
        *service_information = NULL;
394
655
 
395
656
        return CORBA_FALSE;
444
705
        return retval;
445
706
}
446
707
 
 
708
/** The InvalidName exception is raised at @ev when
 
709
 *  ORB.resolve_initial_references is passed an @identifier for which
 
710
 *  there is no initial reference.
 
711
 */
447
712
CORBA_Object
448
713
CORBA_ORB_resolve_initial_references (CORBA_ORB          orb,
449
714
                                      const CORBA_char  *identifier,
451
716
{
452
717
        CORBA_Object objref;
453
718
 
454
 
        if (!orb->initial_refs)
 
719
        /* FIXME, verify identifier and raise exception for invalid
 
720
         * service names, valid names might be: NameService, RootPOA,
 
721
         * SecurityCurrent, PolicyCurrent, etc. */
 
722
 
 
723
        if (!orb->initial_refs ||
 
724
            !(objref = g_hash_table_lookup (orb->initial_refs, identifier)))
455
725
                return CORBA_OBJECT_NIL;
456
 
 
457
 
        objref = g_hash_table_lookup (orb->initial_refs, identifier);
458
 
 
 
726
        
459
727
        return ORBit_RootObject_duplicate (objref);
 
728
#if 0
 
729
 raise_invalid_name:
 
730
        CORBA_exception_set (ev,
 
731
                             CORBA_USER_EXCEPTION,
 
732
                             ex_CORBA_ORB_InvalidName,
 
733
                             NULL);
 
734
        return CORBA_OBJECT_NIL;
 
735
#endif
460
736
}
461
737
 
462
738
static CORBA_TypeCode
463
 
CORBA_TypeCode_allocate (void)
 
739
ORBit_TypeCode_allocate (void)
464
740
{
465
741
        CORBA_TypeCode tc = g_new0 (struct CORBA_TypeCode_struct, 1);
466
742
 
479
755
        CORBA_TypeCode retval;
480
756
        int            i;
481
757
 
482
 
        retval = CORBA_TypeCode_allocate ();
483
 
        if (!retval)
484
 
                goto tc_alloc_failed;
 
758
        retval = ORBit_TypeCode_allocate ();
485
759
 
486
760
        retval->subtypes = g_new0 (CORBA_TypeCode, members->_length);
487
 
        if (!retval->subtypes)
488
 
                goto subtypes_alloc_failed;
489
 
 
490
761
        retval->subnames = g_new0 (char *, members->_length);
491
 
        if (!retval->subnames)
492
 
                goto subnames_alloc_failed;
493
762
 
494
763
        retval->kind      = CORBA_tk_struct;
495
764
        retval->name      = g_strdup (name);
507
776
        }
508
777
 
509
778
        return retval;
510
 
 
511
 
 subnames_alloc_failed:
512
 
        g_free (retval->subtypes);
513
 
 
514
 
 subtypes_alloc_failed:
515
 
        ORBit_RootObject_release (retval);
516
 
 
517
 
 tc_alloc_failed:
518
 
        CORBA_exception_set_system (
519
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
520
 
 
521
 
        return CORBA_OBJECT_NIL;
522
779
}
523
780
 
524
781
static void
525
782
copy_case_value (CORBA_long *dest,
526
783
                 CORBA_any  *src)
527
784
{
528
 
        switch (src->_type->kind) {
 
785
        CORBA_TypeCode tc = src->_type;
 
786
 
 
787
        if (tc->kind == CORBA_tk_alias)
 
788
                tc = tc->subtypes [0];
 
789
 
 
790
        switch (tc->kind) {
529
791
        case CORBA_tk_ulong:
530
792
        case CORBA_tk_long:
531
793
        case CORBA_tk_enum:
557
819
        CORBA_TypeCode retval;
558
820
        int            i;
559
821
 
560
 
        retval = CORBA_TypeCode_allocate ();
561
 
 
562
 
        if (!retval)
563
 
                goto tc_alloc_failed;
 
822
        retval = ORBit_TypeCode_allocate ();
564
823
 
565
824
        retval->discriminator = ORBit_RootObject_duplicate (discriminator_type);
566
825
                
567
 
        retval->subtypes = g_new0 (CORBA_TypeCode, members->_length);
568
 
        if (!retval)
569
 
                goto subtypes_alloc_failed;
570
 
 
571
 
        retval->subnames = g_new0 (char *, members->_length);
572
 
        if(!retval->subnames)
573
 
                goto subnames_alloc_failed;
574
 
 
 
826
        retval->subtypes  = g_new0 (CORBA_TypeCode, members->_length);
 
827
        retval->subnames  = g_new0 (char *, members->_length);
575
828
        retval->sublabels = g_new0 (CORBA_long, members->_length);
576
 
        if (!retval->sublabels)
577
 
                goto sublabels_alloc_failed;
578
829
 
579
830
        retval->kind          = CORBA_tk_union;
580
831
        retval->name          = g_strdup (name);
598
849
        }
599
850
 
600
851
        return retval;
601
 
 
602
 
 sublabels_alloc_failed:
603
 
        g_free (retval->sublabels);
604
 
 
605
 
 subnames_alloc_failed:
606
 
        g_free (retval->subtypes);
607
 
 
608
 
 subtypes_alloc_failed:
609
 
        ORBit_free (retval->discriminator);
610
 
        ORBit_RootObject_release (retval);
611
 
 
612
 
 tc_alloc_failed:
613
 
        CORBA_exception_set_system (
614
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
615
 
 
616
 
        return CORBA_OBJECT_NIL;
617
852
}
618
853
 
619
854
CORBA_TypeCode
626
861
        CORBA_TypeCode retval;
627
862
        int            i;
628
863
 
629
 
        retval = CORBA_TypeCode_allocate ();
630
 
        if (!retval)
631
 
                goto tc_alloc_failed;
 
864
        retval = ORBit_TypeCode_allocate ();
632
865
 
633
866
        retval->subnames=g_new0 (char *, members->_length);
634
 
        if (!retval->subnames)
635
 
                goto subnames_alloc_failed;
636
867
 
637
868
        retval->kind      = CORBA_tk_enum;
638
869
        retval->name      = g_strdup (name);
644
875
                retval->subnames [i] = g_strdup (members->_buffer [i]);
645
876
 
646
877
        return retval;
647
 
 
648
 
 subnames_alloc_failed:
649
 
        ORBit_RootObject_release (retval);
650
 
 
651
 
 tc_alloc_failed:
652
 
        CORBA_exception_set_system (
653
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
654
 
 
655
 
        return CORBA_OBJECT_NIL;
656
878
}
657
879
 
658
880
CORBA_TypeCode
664
886
{
665
887
        CORBA_TypeCode retval;
666
888
 
667
 
        retval = CORBA_TypeCode_allocate ();
668
 
        if (!retval)
669
 
                goto tc_alloc_failed;
 
889
        retval = ORBit_TypeCode_allocate ();
670
890
        
671
891
        retval->subtypes = g_new0 (CORBA_TypeCode, 1);
672
 
        if (!retval->subtypes)
673
 
                goto subtypes_alloc_failed;
674
892
 
675
893
        retval->kind      = CORBA_tk_alias;
676
894
        retval->name      = g_strdup (name);
681
899
        retval->subtypes [0] = ORBit_RootObject_duplicate (original_type);
682
900
 
683
901
        return retval;
684
 
 
685
 
 subtypes_alloc_failed:
686
 
        ORBit_RootObject_release (retval);
687
 
 
688
 
 tc_alloc_failed:
689
 
        CORBA_exception_set_system (
690
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
691
 
 
692
 
        return CORBA_OBJECT_NIL;
693
902
}
694
903
 
695
904
CORBA_TypeCode
702
911
        CORBA_TypeCode retval;
703
912
        int            i;
704
913
 
705
 
        retval = CORBA_TypeCode_allocate ();
706
 
        if (!retval)
707
 
                goto tc_alloc_failed;
 
914
        retval = ORBit_TypeCode_allocate ();
708
915
 
709
916
        if (members->_length) {
710
917
                retval->subtypes = g_new0 (CORBA_TypeCode, members->_length);
711
 
                if (!retval->subtypes)
712
 
                        goto subtypes_alloc_failed;
713
 
 
714
918
                retval->subnames = g_new0 (char *, members->_length);
715
 
                if (!retval->subnames)
716
 
                        goto subnames_alloc_failed;
717
919
        }
718
920
 
719
921
        retval->kind      = CORBA_tk_except;
732
934
        }
733
935
 
734
936
        return retval;
735
 
 
736
 
 subnames_alloc_failed:
737
 
        g_free (retval->subtypes);
738
 
 
739
 
 subtypes_alloc_failed:
740
 
        ORBit_RootObject_release (retval);
741
 
 
742
 
 tc_alloc_failed:
743
 
        CORBA_exception_set_system (
744
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
745
 
 
746
 
        return CORBA_OBJECT_NIL;
747
937
}
748
938
 
749
939
CORBA_TypeCode
754
944
{
755
945
        CORBA_TypeCode retval;
756
946
 
757
 
        retval = CORBA_TypeCode_allocate ();
758
 
        if (!retval) {
759
 
                CORBA_exception_set_system (
760
 
                                ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
761
 
 
762
 
                return CORBA_OBJECT_NIL;
763
 
        }
 
947
        retval = ORBit_TypeCode_allocate ();
764
948
 
765
949
        retval->kind    = CORBA_tk_objref;
766
950
        retval->name    = g_strdup (name);
776
960
{
777
961
        CORBA_TypeCode retval;
778
962
 
779
 
        retval = CORBA_TypeCode_allocate ();
780
 
        if (!retval) {
781
 
                CORBA_exception_set_system (
782
 
                                ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
783
 
 
784
 
                return CORBA_OBJECT_NIL;
785
 
        }
 
963
        retval = ORBit_TypeCode_allocate ();
786
964
 
787
965
        retval->kind   = CORBA_tk_string;
788
966
        retval->length = bound;
797
975
{
798
976
        CORBA_TypeCode retval;
799
977
 
800
 
        retval = CORBA_TypeCode_allocate ();
801
 
        if (!retval) {
802
 
                CORBA_exception_set_system (
803
 
                                ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
804
 
 
805
 
                return CORBA_OBJECT_NIL;
806
 
        }
 
978
        retval = ORBit_TypeCode_allocate ();
807
979
 
808
980
        retval->kind   = CORBA_tk_wstring;
809
981
        retval->length = bound;
819
991
{
820
992
        CORBA_TypeCode retval;
821
993
 
822
 
        retval = CORBA_TypeCode_allocate ();
823
 
        if (!retval) {
824
 
                CORBA_exception_set_system (
825
 
                                ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
826
 
 
827
 
                return CORBA_OBJECT_NIL;
828
 
        }
 
994
        retval = ORBit_TypeCode_allocate ();
829
995
 
830
996
        retval->kind   = CORBA_tk_fixed;
831
997
        retval->digits = digits;
842
1008
{
843
1009
        CORBA_TypeCode retval;
844
1010
 
845
 
        retval = CORBA_TypeCode_allocate ();
846
 
        if (!retval)
847
 
                goto tc_alloc_failed;
 
1011
        retval = ORBit_TypeCode_allocate ();
848
1012
 
849
1013
        retval->subtypes = g_new0 (CORBA_TypeCode, 1);
850
 
        if (!retval->subtypes)
851
 
                goto subtypes_alloc_failed;
852
1014
 
853
1015
        retval->kind      = CORBA_tk_sequence;
854
1016
        retval->sub_parts = 1;
857
1019
        retval->subtypes [0] = ORBit_RootObject_duplicate (element_type);
858
1020
 
859
1021
        return retval;
860
 
 
861
 
 subtypes_alloc_failed:
862
 
        ORBit_RootObject_release (retval);
863
 
 
864
 
 tc_alloc_failed:
865
 
        CORBA_exception_set_system (
866
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
867
 
 
868
 
        return CORBA_OBJECT_NIL;
869
1022
}
870
1023
 
871
1024
CORBA_TypeCode
876
1029
{
877
1030
        CORBA_TypeCode retval;
878
1031
 
879
 
        retval=CORBA_TypeCode_allocate ();
880
 
        if (retval)
881
 
                goto tc_alloc_failed;
 
1032
        retval=ORBit_TypeCode_allocate ();
882
1033
 
883
1034
        retval->subtypes = g_new0 (CORBA_TypeCode, 1);
884
 
        if (!retval->subtypes)
885
 
                goto subtypes_alloc_failed;
886
1035
 
887
1036
        retval->kind      = CORBA_tk_sequence;
888
1037
        retval->sub_parts = 1;
889
1038
        retval->length    = bound;
890
1039
 
891
 
        retval->subtypes [0] = CORBA_TypeCode_allocate ();
 
1040
        retval->subtypes [0] = ORBit_TypeCode_allocate ();
892
1041
 
893
1042
        retval->subtypes [0]->kind          = CORBA_tk_recursive;
894
1043
        retval->subtypes [0]->recurse_depth = offset;
895
1044
 
896
1045
        return retval;
897
 
 
898
 
 subtypes_alloc_failed:
899
 
        ORBit_RootObject_release (retval);
900
 
 
901
 
 tc_alloc_failed:
902
 
        CORBA_exception_set_system (
903
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
904
 
 
905
 
        return CORBA_OBJECT_NIL;
906
1046
}
907
1047
 
908
1048
CORBA_TypeCode
913
1053
{
914
1054
        CORBA_TypeCode tc;
915
1055
 
916
 
        tc = CORBA_TypeCode_allocate ();
917
 
        if (!tc)
918
 
                goto tc_alloc_failed;
 
1056
        tc = ORBit_TypeCode_allocate ();
919
1057
 
920
1058
        tc->subtypes = g_new0 (CORBA_TypeCode, 1);
921
 
        if (!tc->subtypes)
922
 
                goto subtypes_alloc_failed;
923
1059
 
924
1060
        tc->kind      = CORBA_tk_array;
925
1061
        tc->sub_parts = 1;
928
1064
        tc->subtypes [0] = ORBit_RootObject_duplicate (element_type);
929
1065
 
930
1066
        return (tc);
931
 
 
932
 
 subtypes_alloc_failed:
933
 
        ORBit_RootObject_release (tc);
934
 
 
935
 
 tc_alloc_failed:
936
 
        CORBA_exception_set_system (
937
 
                        ev, ex_CORBA_NO_MEMORY, CORBA_COMPLETED_NO);
938
 
 
939
 
        return CORBA_OBJECT_NIL;
940
1067
}
941
1068
 
942
1069
CORBA_TypeCode
991
1118
CORBA_ORB_work_pending (CORBA_ORB          orb,
992
1119
                        CORBA_Environment *ev)
993
1120
{
994
 
        return linc_main_pending ();
 
1121
        return link_main_pending ();
995
1122
}
996
1123
 
997
1124
void
998
1125
CORBA_ORB_perform_work (CORBA_ORB          orb,
999
1126
                        CORBA_Environment *ev)
1000
1127
{
1001
 
        linc_main_iteration (FALSE);
 
1128
        link_main_iteration (FALSE);
1002
1129
}
1003
1130
 
1004
1131
void
1005
1132
CORBA_ORB_run (CORBA_ORB          orb,
1006
1133
               CORBA_Environment *ev)
1007
1134
{
1008
 
        linc_main_loop_run ();
 
1135
        giop_main_run ();
1009
1136
}
1010
1137
 
1011
1138
void
1015
1142
{
1016
1143
        PortableServer_POA root_poa;
1017
1144
 
1018
 
        if (init_level > 0)
1019
 
                return;
1020
 
 
1021
1145
        root_poa = g_ptr_array_index (orb->adaptors, 0);
1022
1146
        if (root_poa) {
1023
1147
                PortableServer_POA_destroy (
1024
1148
                        root_poa, TRUE, wait_for_completion, ev);
1025
 
                if (ev->_major)
1026
 
                        return;
 
1149
                if (ev->_major) {
 
1150
                        if (wait_for_completion)
 
1151
                                g_warning ("FIXME: wait for "
 
1152
                                           "completion unimplemented");
 
1153
                        else
 
1154
                                return;
 
1155
                }
1027
1156
        }
1028
1157
 
 
1158
        giop_shutdown ();
 
1159
 
1029
1160
        ORBit_ORB_shutdown_servers (orb);
1030
 
 
1031
 
        giop_connection_remove_by_orb (orb);
1032
 
 
1033
 
        g_main_loop_quit (linc_loop);
1034
1161
}
1035
1162
 
1036
1163
void
1047
1174
        if (init_level > 0)
1048
1175
                return;
1049
1176
 
 
1177
        CORBA_ORB_shutdown (orb, TRUE, ev);
 
1178
 
1050
1179
        g_assert (_ORBit_orb == orb);
1051
1180
        _ORBit_orb = NULL;
1052
1181
 
1053
 
        CORBA_ORB_shutdown (orb, TRUE, ev);
1054
1182
        if (ev->_major)
1055
1183
                return;
1056
1184
 
1057
1185
        root_poa = g_ptr_array_index (orb->adaptors, 0);
1058
1186
        if (root_poa &&
1059
1187
            ((ORBit_RootObject) root_poa)->refs != 1) {
1060
 
                g_warning ("CORBA_ORB_destroy: Application still has %d "
1061
 
                           "refs to RootPOA.",
1062
 
                           ((ORBit_RootObject)root_poa)->refs - 1);
 
1188
#ifdef G_ENABLE_DEBUG
 
1189
                if (!atexit_shutdown)
 
1190
                        g_warning ("CORBA_ORB_destroy: Application still has %d "
 
1191
                                   "refs to RootPOA.",
 
1192
                                   ((ORBit_RootObject)root_poa)->refs - 1);
 
1193
#endif
1063
1194
                CORBA_exception_set_system (
1064
1195
                        ev, ex_CORBA_FREE_MEM, CORBA_COMPLETED_NO);
1065
1196
        }
1086
1217
                }
1087
1218
 
1088
1219
                if (leaked_adaptors) {
1089
 
                        g_warning ("CORBA_ORB_destroy: leaked '%d' Object Adaptors", leaked_adaptors);
 
1220
#ifdef G_ENABLE_DEBUG
 
1221
                        if (!atexit_shutdown)
 
1222
                                g_warning ("CORBA_ORB_destroy: leaked '%d' Object Adaptors",
 
1223
                                           leaked_adaptors);
 
1224
#endif
1090
1225
                        CORBA_exception_set_system (
1091
1226
                                ev, ex_CORBA_FREE_MEM, CORBA_COMPLETED_NO);
1092
1227
                }
1093
1228
 
1094
1229
                if (((ORBit_RootObject)orb)->refs != 2 + leaked_adaptors) {
1095
 
                        g_warning ("CORBA_ORB_destroy: ORB still has %d refs.",
1096
 
                                   ((ORBit_RootObject)orb)->refs - 1 - leaked_adaptors);
 
1230
#ifdef G_ENABLE_DEBUG
 
1231
                        if (!atexit_shutdown) {
 
1232
                                if (((ORBit_RootObject)orb)->refs == 1 + leaked_adaptors)
 
1233
                                        g_warning ("CORBA_ORB_destroy: ORB unreffed but not _destroy'd");
 
1234
                                else
 
1235
                                        g_warning ("CORBA_ORB_destroy: ORB still has %d refs.",
 
1236
                                                   ((ORBit_RootObject)orb)->refs - 1 - leaked_adaptors);
 
1237
                        }
 
1238
#endif
1097
1239
                        CORBA_exception_set_system (
1098
1240
                                ev, ex_CORBA_FREE_MEM, CORBA_COMPLETED_NO);
1099
1241
                }
1105
1247
 
1106
1248
        /* At this stage there should be 1 ref left in the system -
1107
1249
         * on the ORB */
1108
 
        if (ORBit_RootObject_shutdown ())
 
1250
        if (ORBit_RootObject_shutdown (!atexit_shutdown))
1109
1251
                CORBA_exception_set_system (
1110
1252
                        ev, ex_CORBA_FREE_MEM, CORBA_COMPLETED_NO);
1111
1253
}
1148
1290
                             gchar     *identifier,
1149
1291
                             gpointer   objref)
1150
1292
{
 
1293
        CORBA_Object old_objref;
 
1294
 
1151
1295
        if (!orb->initial_refs)
1152
1296
                orb->initial_refs = g_hash_table_new (g_str_hash, g_str_equal);
1153
1297
 
1154
 
        if (g_hash_table_lookup (orb->initial_refs, identifier))
 
1298
        if ((old_objref = g_hash_table_lookup (orb->initial_refs, identifier))) {
 
1299
                ORBit_RootObject_release (old_objref);
1155
1300
                g_hash_table_remove (orb->initial_refs, identifier);
 
1301
        }
1156
1302
 
1157
1303
        g_hash_table_insert (orb->initial_refs,
1158
1304
                             identifier,
1182
1328
        return FALSE;
1183
1329
}
1184
1330
 
1185
 
static ORBit_option orbit_supported_options[] = {
1186
 
        {"ORBid",           ORBIT_OPTION_STRING,  NULL}, /* FIXME: unimplemented */
1187
 
        {"ORBImplRepoIOR",  ORBIT_OPTION_STRING,  NULL}, /* FIXME: unimplemented */
1188
 
        {"ORBIfaceRepoIOR", ORBIT_OPTION_STRING,  NULL}, /* FIXME: unimplemented */
1189
 
        {"ORBNamingIOR",    ORBIT_OPTION_STRING,  NULL}, /* FIXME: unimplemented */
1190
 
        {"ORBRootPOAIOR",   ORBIT_OPTION_STRING,  NULL}, /* FIXME: huh?          */
1191
 
        {"ORBIIOPIPName",   ORBIT_OPTION_STRING,  &orbit_ipname},
1192
 
        {"ORBIIOPIPSock",   ORBIT_OPTION_STRING,  &orbit_ipsock},
1193
 
        {"ORBIIOPIPv4",     ORBIT_OPTION_BOOLEAN, &orbit_use_ipv4},
1194
 
        {"ORBIIOPIPv6",     ORBIT_OPTION_BOOLEAN, &orbit_use_ipv6},
1195
 
        {"ORBIIOPUSock",    ORBIT_OPTION_BOOLEAN, &orbit_use_usocks},
1196
 
        {"ORBIIOPUNIX",     ORBIT_OPTION_BOOLEAN, &orbit_use_usocks},
1197
 
        {"ORBIIOPIrDA",     ORBIT_OPTION_BOOLEAN, &orbit_use_irda},
1198
 
        {"ORBIIOPSSL",      ORBIT_OPTION_BOOLEAN, &orbit_use_ssl},
1199
 
        {"ORBSimpleUIDs",   ORBIT_OPTION_BOOLEAN, &orbit_use_genuid_simple},
1200
 
        {"ORBDebugFlags",   ORBIT_OPTION_STRING,  &orbit_debug_options},
1201
 
        {NULL,              0,                    NULL},
 
1331
const ORBit_option orbit_supported_options[] = {
 
1332
        { "ORBid",              ORBIT_OPTION_STRING,  NULL }, /* FIXME: unimplemented */
 
1333
        { "ORBImplRepoIOR",     ORBIT_OPTION_STRING,  NULL }, /* FIXME: unimplemented */
 
1334
        { "ORBIfaceRepoIOR",    ORBIT_OPTION_STRING,  NULL }, /* FIXME: unimplemented */
 
1335
        { "ORBNamingIOR",       ORBIT_OPTION_STRING,  &orbit_naming_ref},
 
1336
 
 
1337
        { "ORBRootPOAIOR",      ORBIT_OPTION_STRING,  NULL }, /* FIXME: huh?          */
 
1338
        { "ORBIIOPIPName",      ORBIT_OPTION_STRING,  &orbit_ipname },
 
1339
        { "ORBIIOPIPSock",      ORBIT_OPTION_STRING,  &orbit_ipsock },
 
1340
        { "ORBInitialMsgLimit", ORBIT_OPTION_INT,     &orbit_initial_recv_limit },
 
1341
        { "ORBLocalOnly",       ORBIT_OPTION_BOOLEAN, &orbit_local_only },
 
1342
        /* warning: this option is a security risk unless used with LocalOnly */
 
1343
        { "ORBIIOPIPv4",        ORBIT_OPTION_BOOLEAN, &orbit_use_ipv4 },
 
1344
        { "ORBIIOPIPv6",        ORBIT_OPTION_BOOLEAN, &orbit_use_ipv6 },
 
1345
        { "ORBIIOPUSock",       ORBIT_OPTION_BOOLEAN, &orbit_use_usocks },
 
1346
        { "ORBIIOPUNIX",        ORBIT_OPTION_BOOLEAN, &orbit_use_usocks },
 
1347
        { "ORBIIOPIrDA",        ORBIT_OPTION_BOOLEAN, &orbit_use_irda },
 
1348
        { "ORBIIOPSSL",         ORBIT_OPTION_BOOLEAN, &orbit_use_ssl },
 
1349
        /* warning: this option is a security risk */
 
1350
        { "ORBHTTPIORs",        ORBIT_OPTION_BOOLEAN, &orbit_use_http_iors },
 
1351
        /* warning: this option is a security risk */
 
1352
        { "ORBSimpleUIDs",      ORBIT_OPTION_BOOLEAN, &orbit_use_genuid_simple },
 
1353
        { "ORBDebugFlags",      ORBIT_OPTION_STRING,  &orbit_debug_options },
 
1354
        { "ORBInitRef",         ORBIT_OPTION_KEY_VALUE,  &orbit_initref_list},
 
1355
        { "ORBCorbaloc",        ORBIT_OPTION_BOOLEAN, &orbit_use_corbaloc},
 
1356
        { NULL,                 0,                    NULL },
1202
1357
};