Fri, 24 Sep 2010 22:42:14 -0700
6891766: Vulnerabilities in use of reflection in CORBA
Reviewed-by: hawtin
1 /*
2 * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
26 /*
27 * This file contains OMG IDL from CORBA V2.0, July 1995.
28 * It also contains the TypeCode creation APIs in CORBA::ORB
29 **/
31 #pragma prefix "omg.org"
32 //#pragma javaPackage org.omg
34 module CORBA {
35 typedef string Identifier;
36 typedef string ScopedName;
37 typedef string RepositoryId;
39 enum DefinitionKind {
40 dk_none, dk_all,
41 dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
42 dk_Module, dk_Operation, dk_Typedef,
43 dk_Alias, dk_Struct, dk_Union, dk_Enum,
44 dk_Primitive, dk_String, dk_Sequence, dk_Array,
45 dk_Repository,
46 dk_Wstring, dk_Fixed,
47 dk_Value, dk_ValueBox, dk_ValueMember, // orbos 98-01-18: Objects By Value
48 dk_Native
49 };
52 interface IRObject
53 /**
54 An IRObject IDL interface represents the most generic interface
55 from which all other Interface Repository interfaces are derived,
56 even the Repository itself.
57 */
58 {
59 // read interface
60 readonly attribute DefinitionKind def_kind;
62 // write interface
63 void destroy ();
64 };
68 typedef string VersionSpec;
70 interface Contained;
71 interface Repository;
72 interface Container;
74 interface Contained : IRObject
75 /**
76 The Contained Interface is inherited by all Interface Repository
77 interfaces that are contained by other objects.
78 */
79 {
80 // read/write interface
82 attribute RepositoryId id;
83 attribute Identifier name;
84 attribute VersionSpec version;
86 // read interface
88 readonly attribute Container defined_in;
89 readonly attribute ScopedName absolute_name;
90 readonly attribute Repository containing_repository;
92 struct Description {
93 DefinitionKind kind;
94 any value;
95 };
97 Description describe ();
99 // write interface
101 void move (
102 in Container new_container,
103 in Identifier new_name,
104 in VersionSpec new_version
105 );
106 };
109 interface ModuleDef;
110 interface ConstantDef;
111 interface IDLType;
112 interface StructDef;
113 interface UnionDef;
114 interface EnumDef;
115 interface AliasDef;
116 interface InterfaceDef;
117 interface ExceptionDef;
118 interface ValueDef; // orbos 98-01-18: Objects By Value
119 interface ValueMemberDef; // orbos 98-01-18: Objects By Value
120 interface ValueBoxDef; // orbos 98-01-18: Objects By Value
121 interface NativeDef;
124 typedef sequence <InterfaceDef> InterfaceDefSeq;
127 typedef sequence <Contained> ContainedSeq;
129 struct StructMember {
130 Identifier name;
131 TypeCode type;
132 IDLType type_def;
133 };
134 typedef sequence <StructMember> StructMemberSeq;
136 struct UnionMember {
137 Identifier name;
138 any label;
139 TypeCode type;
140 IDLType type_def;
141 };
142 typedef sequence <UnionMember> UnionMemberSeq;
145 typedef sequence <Identifier> EnumMemberSeq;
147 // orbos 98-01-18: Objects By Value -- begin
148 typedef short Visibility;
149 const Visibility PRIVATE_MEMBER = 0;
150 const Visibility PUBLIC_MEMBER = 1;
152 struct ValueMember {
153 Identifier name;
154 RepositoryId id;
155 RepositoryId defined_in;
156 VersionSpec version;
157 TypeCode type;
158 IDLType type_def;
159 Visibility access;
160 };
161 typedef sequence <ValueMember> ValueMemberSeq;
163 struct Initializer {
164 StructMemberSeq members;
165 };
166 typedef sequence <Initializer> InitializerSeq;
168 typedef sequence <ValueDef> ValueDefSeq;
170 // orbos 98-01-18: Objects By Value -- end
173 interface Container : IRObject
174 /**
175 The Container interface is used to form a containment hierarchy
176 in the Interface Repository. A Container can contain any number
177 of objects derived from the Contained interface.
178 */
179 {
180 // read interface
182 Contained lookup ( in ScopedName search_name);
184 ContainedSeq contents (
185 in DefinitionKind limit_type,
186 in boolean exclude_inherited
187 );
189 ContainedSeq lookup_name (
190 in Identifier search_name,
191 in long levels_to_search,
192 in DefinitionKind limit_type,
193 in boolean exclude_inherited
194 );
196 struct Description {
197 Contained contained_object;
198 DefinitionKind kind;
199 any value;
200 };
202 typedef sequence<Description> DescriptionSeq;
204 DescriptionSeq describe_contents (
205 in DefinitionKind limit_type,
206 in boolean exclude_inherited,
207 in long max_returned_objs
208 );
210 // write interface
212 ModuleDef create_module (
213 in RepositoryId id,
214 in Identifier name,
215 in VersionSpec version
216 );
218 ConstantDef create_constant (
219 in RepositoryId id,
220 in Identifier name,
221 in VersionSpec version,
222 in IDLType type,
223 in any value
224 );
226 StructDef create_struct (
227 in RepositoryId id,
228 in Identifier name,
229 in VersionSpec version,
230 in StructMemberSeq members
231 );
233 UnionDef create_union (
234 in RepositoryId id,
235 in Identifier name,
236 in VersionSpec version,
237 in IDLType discriminator_type,
238 in UnionMemberSeq members
239 );
241 EnumDef create_enum (
242 in RepositoryId id,
243 in Identifier name,
244 in VersionSpec version,
245 in EnumMemberSeq members
246 );
248 AliasDef create_alias (
249 in RepositoryId id,
250 in Identifier name,
251 in VersionSpec version,
252 in IDLType original_type
253 );
255 ExceptionDef create_exception (
256 in RepositoryId id,
257 in Identifier name,
258 in VersionSpec version,
259 in StructMemberSeq members
260 );
263 InterfaceDef create_interface (
264 in RepositoryId id,
265 in Identifier name,
266 in VersionSpec version,
267 in boolean is_abstract,
268 in InterfaceDefSeq base_interfaces
269 );
271 // orbos 98-01-18: Objects By Value
272 ValueDef create_value(
273 in RepositoryId id,
274 in Identifier name,
275 in VersionSpec version,
276 in boolean is_custom,
277 in boolean is_abstract,
278 in octet flags, // must be 0
279 in ValueDef base_value,
280 in boolean has_safe_base,
281 in ValueDefSeq abstract_base_values,
282 in InterfaceDefSeq supported_interfaces,
283 in InitializerSeq initializers
284 );
286 // orbos 98-01-18: Objects By Value
287 ValueBoxDef create_value_box(
288 in RepositoryId id,
289 in Identifier name,
290 in VersionSpec version,
291 in IDLType original_type_def
292 );
294 NativeDef create_native(
295 in RepositoryId id,
296 in Identifier name,
297 in VersionSpec version
298 );
300 };
304 interface IDLType : IRObject
305 /**
306 The IDLType interface is an abstract interface inherited by all
307 IR objects that represent the OMG IDL types. It provides access
308 to the TypeCode describing the type, and is used in defining the
309 other interfaces wherever definitions of IDLType must be referenced.
310 */
311 {
312 readonly attribute TypeCode type;
313 };
317 interface PrimitiveDef;
318 interface StringDef;
319 interface SequenceDef;
320 interface ArrayDef;
322 enum PrimitiveKind {
323 pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
324 pk_float, pk_double, pk_boolean, pk_char, pk_octet,
325 pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref
326 };
328 interface Repository : Container
329 /**
330 Repository is an interface that provides global access to the
331 Interface Repository. Repository objects can contain constants,
332 typedefs, exceptions, interfaces, and modules.
333 */
334 {
335 // read interface
337 Contained lookup_id (in RepositoryId search_id);
339 PrimitiveDef get_primitive (in PrimitiveKind kind);
341 // write interface
343 StringDef create_string (in unsigned long bound);
345 SequenceDef create_sequence (
346 in unsigned long bound,
347 in IDLType element_type
348 );
350 ArrayDef create_array (
351 in unsigned long length,
352 in IDLType element_type
353 );
354 };
357 interface ModuleDef : Container, Contained
358 /**
359 A ModuleDef can contain constants, typedefs, exceptions, interfaces,
360 and other module objects.
361 */
362 {
363 };
365 struct ModuleDescription {
366 Identifier name;
367 RepositoryId id;
368 RepositoryId defined_in;
369 VersionSpec version;
370 };
373 interface ConstantDef : Contained
374 /**
375 A ConstantDef object defines a named constant.
376 */
377 {
378 readonly attribute TypeCode type;
379 attribute IDLType type_def;
380 attribute any value;
381 };
383 struct ConstantDescription {
384 Identifier name;
385 RepositoryId id;
386 RepositoryId defined_in;
387 VersionSpec version;
388 TypeCode type;
389 any value;
390 };
393 interface TypedefDef : Contained, IDLType
394 /**
395 TypedefDef is an abstract interface used as a base interface for
396 all named non-object types(structures, unions, enumerations,
397 aliases). The TypedefDef interface is not inherited by the definition
398 objects for the primitive or anonymous types.
399 */
400 {
401 };
403 struct TypeDescription {
404 Identifier name;
405 RepositoryId id;
406 RepositoryId defined_in;
407 VersionSpec version;
408 TypeCode type;
409 };
412 interface StructDef : TypedefDef, Container
413 /**
414 A StructDef represents an OMG IDL structure definition.
415 */
416 {
417 attribute StructMemberSeq members;
418 };
421 interface UnionDef : TypedefDef, Container
422 /**
423 A UnionDef represents an OMG IDL union definition.
424 */
425 {
426 readonly attribute TypeCode discriminator_type;
427 attribute IDLType discriminator_type_def;
428 attribute UnionMemberSeq members;
429 };
432 interface EnumDef : TypedefDef
433 /**
434 A EnumDef represents an OMG IDL enum definition.
435 */
436 {
437 attribute EnumMemberSeq members;
438 };
441 interface AliasDef : TypedefDef
442 /**
443 An AliasDef represents an OMG IDL typedef that aliases other
444 definition.
445 */
446 {
447 attribute IDLType original_type_def;
448 };
451 interface PrimitiveDef: IDLType
452 /**
453 A PrimitiveDef represents one of the IDL primitive types. As
454 primitive types are unnamed, this interface is not derived from
455 TypedefDef or Contained.
456 */
457 {
458 readonly attribute PrimitiveKind kind;
459 };
462 interface StringDef : IDLType
463 /**
464 A StringDef represents an OMG IDL string type. As string
465 types are anonymous, this interface is not derived from TypedefDef
466 or Contained.
467 */
468 {
469 attribute unsigned long bound;
470 };
473 interface SequenceDef : IDLType
474 /**
475 A SequenceDef represents an OMG IDL sequence type. As sequence
476 types are anonymous, this interface is not derived from TypedefDef
477 or Contained.
478 */
479 {
480 attribute unsigned long bound;
481 readonly attribute TypeCode element_type;
482 attribute IDLType element_type_def;
483 };
485 interface ArrayDef : IDLType
486 /**
487 An ArrayDef represents an OMG IDL array type. As array
488 types are anonymous, this interface is not derived from TypedefDef
489 or Contained.
490 */
491 {
492 attribute unsigned long length;
493 readonly attribute TypeCode element_type;
494 attribute IDLType element_type_def;
495 };
498 interface ExceptionDef : Contained, Container
499 /**
500 An ExceptionDef represents an exception definition.
501 */
502 {
503 readonly attribute TypeCode type;
504 attribute StructMemberSeq members;
505 };
506 struct ExceptionDescription {
507 Identifier name;
508 RepositoryId id;
509 RepositoryId defined_in;
510 VersionSpec version;
511 TypeCode type;
512 };
516 enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};
518 interface AttributeDef : Contained
519 /**
520 An AttributeDef represents the information that defines an
521 attribute of an interface.
522 */
523 {
524 readonly attribute TypeCode type;
525 attribute IDLType type_def;
526 attribute AttributeMode mode;
527 };
529 struct AttributeDescription {
530 Identifier name;
531 RepositoryId id;
532 RepositoryId defined_in;
533 VersionSpec version;
534 TypeCode type;
535 AttributeMode mode;
536 };
540 enum OperationMode {OP_NORMAL, OP_ONEWAY};
542 enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
543 struct ParameterDescription {
544 Identifier name;
545 TypeCode type;
546 IDLType type_def;
547 ParameterMode mode;
548 };
549 typedef sequence <ParameterDescription> ParDescriptionSeq;
551 typedef Identifier ContextIdentifier;
552 typedef sequence <ContextIdentifier> ContextIdSeq;
554 typedef sequence <ExceptionDef> ExceptionDefSeq;
555 typedef sequence <ExceptionDescription> ExcDescriptionSeq;
557 interface OperationDef : Contained
558 /**
559 An OperationDef represents the information that defines an
560 operation of an interface.
561 */
562 {
563 readonly attribute TypeCode result;
564 attribute IDLType result_def;
565 attribute ParDescriptionSeq params;
566 attribute OperationMode mode;
567 attribute ContextIdSeq contexts;
568 attribute ExceptionDefSeq exceptions;
569 };
571 struct OperationDescription {
572 Identifier name;
573 RepositoryId id;
574 RepositoryId defined_in;
575 VersionSpec version;
576 TypeCode result;
577 OperationMode mode;
578 ContextIdSeq contexts;
579 ParDescriptionSeq parameters;
580 ExcDescriptionSeq exceptions;
581 };
585 typedef sequence <RepositoryId> RepositoryIdSeq;
586 typedef sequence <OperationDescription> OpDescriptionSeq;
587 typedef sequence <AttributeDescription> AttrDescriptionSeq;
589 interface InterfaceDef : Container, Contained, IDLType
590 /**
591 An InterfaceDef object represents an interface definition. It can
592 contains constants, typedefs, exceptions, operations, and
593 attributes.
594 */
595 {
596 // read/write interface
598 attribute InterfaceDefSeq base_interfaces;
599 attribute boolean is_abstract;
601 // read interface
603 boolean is_a (in RepositoryId interface_id);
605 struct FullInterfaceDescription {
606 Identifier name;
607 RepositoryId id;
608 RepositoryId defined_in;
609 VersionSpec version;
610 boolean is_abstract;
611 OpDescriptionSeq operations;
612 AttrDescriptionSeq attributes;
613 RepositoryIdSeq base_interfaces;
614 TypeCode type;
615 };
617 FullInterfaceDescription describe_interface();
619 // write interface
621 AttributeDef create_attribute (
622 in RepositoryId id,
623 in Identifier name,
624 in VersionSpec version,
625 in IDLType type,
626 in AttributeMode mode
627 );
629 OperationDef create_operation (
630 in RepositoryId id,
631 in Identifier name,
632 in VersionSpec version,
633 in IDLType result,
634 in OperationMode mode,
635 in ParDescriptionSeq params,
636 in ExceptionDefSeq exceptions,
637 in ContextIdSeq contexts
638 );
639 };
641 struct InterfaceDescription {
642 Identifier name;
643 RepositoryId id;
644 RepositoryId defined_in;
645 VersionSpec version;
646 RepositoryIdSeq base_interfaces;
647 };
650 // orbos 98-01-18: Objects By Value -- begin
652 interface ValueMemberDef : Contained
654 /** A <code>ValueMemberDef</code> object represents the public
655 and private data member definition of a <code>Value</code> type
656 */
658 {
659 readonly attribute TypeCode type;
660 attribute IDLType type_def;
661 attribute Visibility access;
662 };
664 interface ValueDef : Container, Contained, IDLType
665 /**
666 A ValueDef object represents the definition of the
667 <code>Value</code> object used to pass the object state
668 between hosts
669 */
671 {
672 // read/write interface
673 attribute InterfaceDefSeq supported_interfaces;
674 attribute InitializerSeq initializers;
675 attribute ValueDef base_value;
676 attribute ValueDefSeq abstract_base_values;
677 attribute boolean is_abstract;
678 attribute boolean is_custom;
679 attribute octet flags; // always 0
680 attribute boolean has_safe_base;
682 // read interface
683 boolean is_a(in RepositoryId value_id);
685 struct FullValueDescription {
686 Identifier name;
687 RepositoryId id;
688 boolean is_abstract;
689 boolean is_custom;
690 octet flags; // always 0
691 RepositoryId defined_in;
692 VersionSpec version;
693 OpDescriptionSeq operations;
694 AttrDescriptionSeq attributes;
695 ValueMemberSeq members;
696 InitializerSeq initializers;
697 RepositoryIdSeq supported_interfaces;
698 RepositoryIdSeq abstract_base_values;
699 boolean has_safe_base;
700 RepositoryId base_value;
701 TypeCode type;
702 };
704 FullValueDescription describe_value();
706 // write interface
708 ValueMemberDef create_value_member(
709 in RepositoryId id,
710 in Identifier name,
711 in VersionSpec version,
712 in IDLType type_def,
713 in Visibility access
714 );
716 AttributeDef create_attribute(
717 in RepositoryId id,
718 in Identifier name,
719 in VersionSpec version,
720 in IDLType type,
721 in AttributeMode mode
722 );
724 OperationDef create_operation(
725 in RepositoryId id,
726 in Identifier name,
727 in VersionSpec version,
728 in IDLType result,
729 in OperationMode mode,
730 in ParDescriptionSeq params,
731 in ExceptionDefSeq exceptions,
732 in ContextIdSeq contexts
733 );
734 };
735 struct ValueDescription {
736 Identifier name;
737 RepositoryId id;
738 boolean is_abstract;
739 boolean is_custom;
740 octet flags; // always 0
741 RepositoryId defined_in;
742 VersionSpec version;
743 RepositoryIdSeq supported_interfaces;
744 RepositoryIdSeq abstract_base_values;
745 boolean has_safe_base;
746 RepositoryId base_value;
747 };
749 interface ValueBoxDef : IDLType
751 /** ValueBoxDef is an interface that reresents a value type with
752 a single data member inside its state section and no
753 inheritance or methods. For example, when transmitting a
754 string or sequence as an actual parameter on an interface
755 operation or as a data member of a value type that is an
756 actual parameter, it may be important to preserve any sharing
757 of the string or sequence within the object graph being
758 transmitted. Because current IDL data types do not preserve
759 referential integrity in this way, this requirement is
760 conveniently handled by using a value type. Value types also
761 support the transmission of nulls (as a distinguished value),
762 whereas IDL data types such as string and sequence (which are
763 mapped to empty strings and sequences) do not. The Java to IDL
764 mapping requires both preservation of referential integrity
765 and transmission of nulls. Because it would be cumbersome to
766 require the full IDL syntax for a value type for this specific
767 usage, this shorthand notation is introduced to cover this use
768 of value types for simple containment of a single data member.
769 */
771 {
772 attribute IDLType original_type_def;
773 };
775 // orbos 98-01-18: Objects By Value -- end
777 enum TCKind {
778 tk_null, tk_void,
779 tk_short, tk_long, tk_ushort, tk_ulong,
780 tk_float, tk_double, tk_boolean, tk_char,
781 tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
782 tk_struct, tk_union, tk_enum, tk_string,
783 tk_sequence, tk_array, tk_alias, tk_except,
784 tk_longlong, tk_ulonglong, tk_longdouble,
785 tk_wchar, tk_wstring, tk_fixed,
786 tk_value, tk_value_box,
787 tk_native,
788 tk_abstract_interface
789 };
791 interface NativeDef : TypedefDef {
792 };
793 };