1 /* ORB.java -- 2 Copyright (C) 2005, 2006 Free Software Foundation, Inc. 3 4 This file is part of GNU Classpath. 5 6 GNU Classpath is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 GNU Classpath is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GNU Classpath; see the file COPYING. If not, write to the 18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 02110-1301 USA. 20 21 Linking this library statically or dynamically with other modules is 22 making a combined work based on this library. Thus, the terms and 23 conditions of the GNU General Public License cover the whole 24 combination. 25 26 As a special exception, the copyright holders of this library give you 27 permission to link this library with independent modules to produce an 28 executable, regardless of the license terms of these independent 29 modules, and to copy and distribute the resulting executable under 30 terms of your choice, provided that you also meet, for each linked 31 independent module, the terms and conditions of the license of that 32 module. An independent module is a module which is not derived from 33 or based on this library. If you modify this library, you may extend 34 this exception to your version of the library, but you are not 35 obligated to do so. If you do not wish to do so, delete this 36 exception statement from your version. */ 37 38 39 package org.omg.CORBA; 40 41 import gnu.CORBA.OrbFocused; 42 import gnu.CORBA.ObjectCreator; 43 import gnu.CORBA.OrbRestricted; 44 import gnu.CORBA.typecodes.FixedTypeCode; 45 import gnu.CORBA.typecodes.GeneralTypeCode; 46 import gnu.CORBA.typecodes.RecordTypeCode; 47 import gnu.CORBA.typecodes.RecursiveTypeCode; 48 49 import org.omg.CORBA.ORBPackage.InconsistentTypeCode; 50 import org.omg.PortableInterceptor.ObjectReferenceTemplate; 51 52 import java.applet.Applet; 53 54 import java.io.BufferedInputStream; 55 import java.io.File; 56 import java.io.FileInputStream; 57 import java.io.IOException; 58 59 import java.util.Properties; 60 61 /** 62 * A central class in CORBA implementation, responsible for sending and handling 63 * remote invocations. ORB also works as a factory for creating instances of 64 * certain CORBA classes. 65 * 66 * Despite the core library contains the fully working CORBA implementation, it 67 * also provides a simple way to plug-in the alternative CORBA support. This is 68 * done by replacing the ORB. The alternative ORB can be specified via 69 * properties, passed to ORB.Init(...). 70 * 71 * When creating an ORB instance, the class name is searched in the following 72 * locations: 73 * <p> 74 * 1. Applet parameter or application string array, if any.<br> 75 * 2. The properties parameter, if any.<br> 76 * 3. The System properties.<br> 77 * 4. The orb.properties file located in the user.home directory (if any).<br> 78 * 5. The orb.properties file located in the java.home/lib directory (if any). 79 * </p> 80 * 81 * The supported properties are: <table border="1"> 82 * <tr> 83 * <td> org.omg.CORBA.ORBClass</td> 84 * <td>The class, implementing the functional ORB, returned by 85 * {@link #init(Applet, Properties)} or {@link #init(String[], Properties)} 86 * </td> 87 * </tr> 88 * <tr> 89 * <td>org.omg.CORBA.ORBSingletonClass</td> 90 * <td>The class, implementing the restricted ORB, returned by {@link #init()}. 91 * </td> 92 * </tr> 93 * <tr> 94 * <td>org.omg.CORBA.ORBInitRef</td> 95 * <td>Specifies the initial reference, accessible by name with the method 96 * {@link #resolve_initial_references(String)}.</td> 97 * </tr> 98 * <tr> 99 * <td>org.omg.CORBA.ORBid</td> 100 * <td>Specifies the name (ORB Id) of this ORB. The ORB Id is later accessible 101 * by {@link ObjectReferenceTemplate#orb_id}. The default value includes the 102 * hashcode of the ORB instance that is normally different for each ORB. 103 * </td> 104 * </tr> 105 * <tr> 106 * <td>org.omg.CORBA.ServerId</td> 107 * <td>Specifies the name (Server Id) of this server. This property assigns 108 * value to the <i>static</i> field, ensuring that all ORB's on the same jre 109 * have the same Server Id. It is normally set as the system property. The 110 * server Id is later accessible as {@link ObjectReferenceTemplate#server_id}. 111 * </td> 112 * </tr> 113 * <tr> 114 * <td>gnu.CORBA.ListenerPort</td> 115 * <td>Specifies that this ORB should serve all its objects on a single port 116 * (for example, "1234") or on a specified port range (for example, 117 * "1100-1108"). The property is used when working with firewals and serves as a 118 * replacement for the proprietary properties like com.ibm.CORBA.ListenerPort 119 * or com.sun.CORBA.POA.ORBPersistentServerPort. The specified port or range 120 * should not overlap with the values, specified for other ORB's. 121 * </td> 122 * </tr> 123 * <tr> 124 * <td>gnu.Corba.SocketFactory</td> 125 * <td>Sets the user-defined server and client socket factory for the ORB being 126 * currently instantiated. Serves as a replacement of the proprietary 127 * property com.sun.CORBA.connection.ORBSocketFactoryClass. To have multiple 128 * types of sockets, instantiate several ORB's with this property each time 129 * set to the different value. 130 * The factory must implement gnu.CORBA.interfaces.SocketFactory. 131 * </td> 132 * </tr> 133 * </table> 134 * <p>The command line accepts the same properties as a keys. When 135 * specifying in the command line, the prefix org.omg.CORBA can be omitted, for 136 * instance<code> -ORBInitRef NameService=IOR:aabbccdd....</code> 137 * </p> 138 * 139 * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) 140 */ 141 public abstract class ORB 142 { 143 /** 144 * By default, {@link #init(String[], Properties)} and 145 * {@link #init(Applet, Properties)} return 146 * the built-in fully functional ORB is returned. If the 147 * <code>props</code> contains the property org.omg.CORBA.ORBClass, 148 * the value of this property is used as a class name to instantiate 149 * a user-defined ORB. 150 */ 151 private static final String FUNCTIONAL_ORB = "org.omg.CORBA.ORBClass"; 152 153 /** 154 * The name of the restricted ORB property. 155 */ 156 private static final String RESTRICTED_ORB = 157 "org.omg.CORBA.ORBSingletonClass"; 158 159 private static final String LISTENER_PORT = 160 OrbFocused.LISTENER_PORT; 161 162 /** 163 * The class, implementing the default fully functional ORB. 164 */ 165 private static final String DEFAULT_FUNCTIONAL_ORB = 166 gnu.CORBA.Poa.ORB_1_4.class.getName(); 167 168 private static final String DEFAULT_FOCUSED_ORB = 169 gnu.CORBA.OrbFocused.class.getName(); 170 171 // There is no need for name of the default restricted ORB as it is 172 // singleton and it is more effectively referred directly. 173 174 /** 175 * Connect the given CORBA object to this ORB. After the object is 176 * connected, it starts receiving remote invocations via this ORB. 177 * 178 * The OMG group recommends to use Portable Object Adapter (POA) instead 179 * of calling this method. 180 * 181 * This method is implemented in the derived Gnu Classpah classes, 182 * returned by ORB.init(..). In this abstract class, the implementation 183 * just throws {@link NO_IMPLEMENT}. 184 * 185 * @param object the org.omg.CORBA.Object to connect. 186 */ connect(org.omg.CORBA.Object object)187 public void connect(org.omg.CORBA.Object object) 188 { 189 throw new NO_IMPLEMENT(); 190 } 191 192 /** 193 * Disconnect the given CORBA object from this ORB. The object will be 194 * no longer receiving the remote invocations. In response to the 195 * remote invocation on this object, the ORB will send the 196 * exception {@link OBJECT_NOT_EXIST}. The object, however, is not 197 * destroyed and can receive the local invocations. 198 * 199 * This method is implemented in the derived Gnu Classpah classes, 200 * returned by ORB.init(..). In this abstract class, the implementation 201 * just throws {@link NO_IMPLEMENT}. 202 * 203 * @param object the object to disconnect. 204 */ disconnect(org.omg.CORBA.Object object)205 public void disconnect(org.omg.CORBA.Object object) 206 { 207 throw new NO_IMPLEMENT(); 208 } 209 210 /** 211 * Create a typecode, representing a tree-like structure. 212 * This structure contains a member that is a sequence of the same type, 213 * as the structure itself. You can imagine as if the folder definition 214 * contains a variable-length array of the enclosed (nested) folder 215 * definitions. In this way, it is possible to have a tree like 216 * structure that can be transferred via CORBA CDR stream. 217 * 218 * @deprecated It is easier and clearler to use a combination of 219 * create_recursive_tc and create_sequence_tc instead. 220 * 221 * @param bound the maximal expected number of the nested components 222 * on each node; 0 if not limited. 223 * 224 * @param offset the position of the field in the returned structure 225 * that contains the sequence of the structures of the same field. 226 * The members before this field are intialised using parameterless 227 * StructMember constructor. 228 * 229 * @return a typecode, defining a stucture, where a member at the 230 * <code>offset</code> position defines an array of the identical 231 * structures. 232 * 233 * @see #create_recursive_tc(String) 234 * @see #create_sequence_tc(int, TypeCode) 235 */ create_recursive_sequence_tc(int bound, int offset)236 public abstract TypeCode create_recursive_sequence_tc(int bound, int offset); 237 238 /** 239 * Create alias typecode for the given typecode. 240 */ create_alias_tc(String id, String name, TypeCode typecode )241 public abstract TypeCode create_alias_tc(String id, String name, 242 TypeCode typecode 243 ); 244 245 /** 246 * Create an instance of the CORBA {@link Any} with the type, intialised 247 * to {@link TCKind#tk_null} 248 */ create_any()249 public abstract Any create_any(); 250 251 /** 252 * Create a typecode, defining an array of the given elements. 253 * 254 * @param length the size of array 255 * @param element_type the array component type. 256 * 257 * @return the corresponding typecode. 258 */ create_array_tc(int length, TypeCode element_type)259 public abstract TypeCode create_array_tc(int length, TypeCode element_type); 260 261 /** 262 * Creates an empty CORBA <code>ContextList</code>. 263 * 264 * @return the newly created context list. 265 */ create_context_list()266 public abstract ContextList create_context_list(); 267 268 /** 269 * The support for {@link DynAny} and derived interfaces 270 * has never been implemented in Sun's java releases, 271 * at least till v1.4 inclusive. 272 * 273 * Since v1.4 this stil missing implementation was replaced 274 * by the new DynamicAny package. 275 * 276 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 277 * 278 * @throws NO_IMPLEMENT, always. 279 */ create_basic_dyn_any(org.omg.CORBA.TypeCode t)280 public DynAny create_basic_dyn_any(org.omg.CORBA.TypeCode t) 281 throws InconsistentTypeCode 282 { 283 throw new NO_IMPLEMENT(); 284 } 285 286 /** 287 * The support for {@link DynAny} and derived interfaces 288 * has never been implemented in Sun's java releases, 289 * at least till v1.4 inclusive. 290 * 291 * Since v1.4 this stil missing implementation was replaced 292 * by the new DynamicAny package. 293 * 294 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 295 * 296 * @throws NO_IMPLEMENT, always. 297 */ create_dyn_any(org.omg.CORBA.Any a)298 public DynAny create_dyn_any(org.omg.CORBA.Any a) 299 { 300 throw new NO_IMPLEMENT(); 301 } 302 303 /** 304 * The support for {@link DynArray} 305 * has never been implemented in Sun's java releases, 306 * at least till v1.4 inclusive. 307 * 308 * Since v1.4 this stil missing implementation was replaced 309 * by the new DynamicAny package. 310 * 311 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 312 * 313 * @throws NO_IMPLEMENT, always. 314 */ create_dyn_array(org.omg.CORBA.TypeCode t)315 public DynArray create_dyn_array(org.omg.CORBA.TypeCode t) 316 throws InconsistentTypeCode 317 { 318 throw new NO_IMPLEMENT(); 319 } 320 321 /** 322 * The support for {@link DynEnum} 323 * has never been implemented in Sun's java releases, 324 * at least till v1.4 inclusive. 325 * 326 * Since v1.4 this stil missing implementation was replaced 327 * by the new DynamicAny package. 328 * 329 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 330 * 331 * @throws NO_IMPLEMENT, always. 332 */ create_dyn_enum(org.omg.CORBA.TypeCode t)333 public DynEnum create_dyn_enum(org.omg.CORBA.TypeCode t) 334 throws InconsistentTypeCode 335 { 336 throw new NO_IMPLEMENT(); 337 } 338 339 /** 340 * The support for {@link DynSequence} 341 * has never been implemented in Sun's java releases, 342 * at least till v1.4 inclusive. 343 * 344 * Since v1.4 this stil missing implementation was replaced 345 * by the new DynamicAny package. 346 * 347 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 348 * 349 * @throws NO_IMPLEMENT, always. 350 */ create_dyn_sequence(org.omg.CORBA.TypeCode t)351 public DynSequence create_dyn_sequence(org.omg.CORBA.TypeCode t) 352 throws InconsistentTypeCode 353 { 354 throw new NO_IMPLEMENT(); 355 } 356 357 /** 358 * The support for {@link DynStruct} and derived interfaces 359 * has never been implemented in Sun's java releases, 360 * at least till v1.4 inclusive. 361 * 362 * Since v1.4 this stil missing implementation was replaced 363 * by the new DynamicAny package. 364 * 365 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 366 * 367 * @throws NO_IMPLEMENT, always. 368 */ create_dyn_struct(org.omg.CORBA.TypeCode t)369 public DynStruct create_dyn_struct(org.omg.CORBA.TypeCode t) 370 throws InconsistentTypeCode 371 { 372 throw new NO_IMPLEMENT(); 373 } 374 375 /** 376 * The support for {@link DynUnion} and derived interfaces 377 * has never been implemented in Sun's java releases, 378 * at least till v1.4 inclusive. 379 * 380 * Since v1.4 this stil missing implementation was replaced 381 * by the new DynamicAny package. 382 * 383 * @deprecated Use {@link org.omg.DynamicAny.DynAnyFactory} 384 * 385 * @throws NO_IMPLEMENT, always. 386 */ create_dyn_union(org.omg.CORBA.TypeCode t)387 public DynUnion create_dyn_union(org.omg.CORBA.TypeCode t) 388 throws InconsistentTypeCode 389 { 390 throw new NO_IMPLEMENT(); 391 } 392 393 /** 394 * Create a typecode, defining the given enumeration. 395 * 396 * @param id the id. 397 * @param name the name. 398 * @param members the memebers 399 * @return the created enumeration. 400 */ create_enum_tc(String id, String name, String[] members )401 public abstract TypeCode create_enum_tc(String id, String name, 402 String[] members 403 ); 404 405 /** 406 * Create an environment (container for exceptions). 407 * 408 * @return the created container. 409 */ create_environment()410 public abstract Environment create_environment(); 411 412 /** 413 * Creates an empty exception list. 414 * 415 * @return the newly created list. 416 */ create_exception_list()417 public abstract ExceptionList create_exception_list(); 418 419 /** 420 * Create the exception typecode. 421 * 422 * @param id the id of exception. 423 * @param name the name of exception. 424 * @param members the members of exception. 425 */ create_exception_tc(String id, String name, StructMember[] members )426 public abstract TypeCode create_exception_tc(String id, String name, 427 StructMember[] members 428 ); 429 430 /** 431 * Creates a TypeCode object for CORBA <code>fixed</code> that is 432 * mapped to java {@link java.math.BigDecimal}. 433 * 434 * @param digits the number of digits in that <code>fixed</code>. 435 * @param scale the number of digits after the decimal point. 436 * 437 * @return the corresponding TypeCode. 438 */ create_fixed_tc(short digits, short scale)439 public TypeCode create_fixed_tc(short digits, short scale) 440 { 441 FixedTypeCode r = new FixedTypeCode(); 442 r.setDigits(digits); 443 r.setScale(scale); 444 return r; 445 } 446 447 /** 448 * Creates a typecode, representing the IDL interface. 449 * 450 * @param id the interface repository id. 451 * @param name the interface name. 452 * 453 * @return the created typecode. 454 */ create_interface_tc(String id, String name)455 public abstract TypeCode create_interface_tc(String id, String name); 456 457 /** 458 * Create an instance of a new {@link NVList}. 459 * 460 * @param count the initial size of the list. If more elements are added, 461 * the list automatically expands. 462 * 463 * @return the created list. 464 */ create_list(int count)465 public abstract NVList create_list(int count); 466 467 /** 468 * Create a new named value. 469 * 470 * @param name the name of the named value 471 * @param any the content of the named value. 472 * @param flags the flags of the named value 473 * 474 * @return the named value. 475 */ create_named_value(String name, Any any, int flags)476 public abstract NamedValue create_named_value(String name, Any any, int flags); 477 478 /** 479 * Send multiple prepared requests one way, do not caring about the answer. 480 * The messages, containing requests, will be marked, indicating that 481 * the sender is not expecting to get a reply. 482 * 483 * @param requests the prepared array of requests. 484 * 485 * @see Request#send_oneway() 486 */ send_multiple_requests_oneway(Request[] requests)487 public abstract void send_multiple_requests_oneway(Request[] requests); 488 489 /** 490 * Send multiple prepared requests expecting to get a reply. All requests 491 * are send in parallel, each in its own separate thread. When the 492 * reply arrives, it is stored in the agreed fields of the corresponing 493 * request data structure. If this method is called repeatedly, 494 * the new requests are added to the set of the currently sent requests, 495 * but the old set is not discarded. 496 * 497 * @param requests the prepared array of requests. 498 * 499 * @see #poll_next_response() 500 * @see #get_next_response() 501 * @see Request#send_deferred() 502 */ send_multiple_requests_deferred(Request[] requests)503 public abstract void send_multiple_requests_deferred(Request[] requests); 504 505 /** 506 * Find if any of the requests that have been previously sent with 507 * {@link #send_multiple_requests_deferred}, have a response yet. 508 * 509 * @return true if there is at least one response to the previously 510 * sent request, false otherwise. 511 */ poll_next_response()512 public abstract boolean poll_next_response(); 513 514 /** 515 * Get the next instance with a response being received. If all currently 516 * sent responses not yet processed, this method pauses till at least one of 517 * them is complete. If there are no requests currently sent, the method 518 * pauses till some request is submitted and the response is received. 519 * This strategy is identical to the one accepted by Suns 1.4 ORB 520 * implementation. 521 * 522 * @return the previously sent request that now contains the received 523 * response. 524 * 525 * @throws WrongTransaction If the method was called from the transaction 526 * scope different than the one, used to send the request. The exception 527 * can be raised only if the request is implicitly associated with some 528 * particular transaction. 529 */ get_next_response()530 public abstract Request get_next_response() 531 throws WrongTransaction; 532 533 /** 534 * Create a new CDR output stream, where the parameter values can be written 535 * during the method invocation. 536 * 537 * @return a stream to write values into. 538 */ create_output_stream()539 public abstract org.omg.CORBA.portable.OutputStream create_output_stream(); 540 541 /** 542 * This should create the list, initialised with the argument descriptions 543 * for the given operation definition (CORBA <code>OperationDef</code>). 544 * The information should be obtained from the interface repository. 545 * However this method is oficially documented as not implemented at least 546 * till v1.4 inclusive. 547 * 548 * @param operation_definition the operation definition, must be 549 * CORBA <code>OperationDef</code>. 550 * 551 * @return never 552 * 553 * @throws NO_IMPLEMENT, always. 554 */ create_operation_list(Object operation_definition)555 public NVList create_operation_list(Object operation_definition) 556 { 557 throw new NO_IMPLEMENT(); 558 } 559 560 /** 561 * <p>Creates the new policy of the specified type, having the given value. 562 * This method looks for the policy factory that was previously registered 563 * during ORB initialization by 564 * {@link org.omg.PortableInterceptor#ORBInitialiser}. 565 * 566 * If the suitable factory is found, this factory creates the requested policy, 567 * otherwise the PolicyError is thrown. 568 * </p><p> 569 * The POA policies should be created by POA, not by this method. 570 * </p> 571 * @param type the policy type. 572 * @param value the policy value, wrapped into Any. 573 * 574 * @throws PolicyError if the ORB fails to instantiate the policy object. 575 * 576 * @throws NO_IMPLEMENT always (in this class). Overridden in derived classes 577 * returned by ORB.init(..). 578 * 579 * @see org.omg.PortableInterceptor.ORBInitInfoOperations#register_policy_factory 580 * @see org.omg.PortableInterceptor.PolicyFactoryOperations 581 */ create_policy(int type, Any value)582 public Policy create_policy(int type, Any value) 583 throws PolicyError 584 { 585 throw new NO_IMPLEMENT(); 586 } 587 588 /** 589 * Create typecode, defining the sequence of the elements, having 590 * the given type. 591 * 592 * @param bound the maximal length of the sequence, 0 if not restricted. 593 * 594 * @param element_type the sequence element type. 595 * 596 * @return the typecode. 597 */ create_sequence_tc(int bound, TypeCode element_type)598 public abstract TypeCode create_sequence_tc(int bound, TypeCode element_type); 599 600 /** 601 * Create a TypeCode, representing the CORBA <code>string</code>. 602 * 603 * @param bound the maximal length of the string, 0 is unlimited. 604 * 605 * @return the corresponding string typecode. 606 */ create_string_tc(int bound)607 public abstract TypeCode create_string_tc(int bound); 608 609 /** 610 * Create the typecode, defining the given IDL structure. 611 * 612 * The TypeCode object is initialized with the given id, name, and members. 613 * @param id the Id of this type. 614 * @param name the name of this type. 615 * @param members the member list. 616 * 617 * @return the typecode. 618 */ create_struct_tc(String id, String name, StructMember[] members )619 public abstract TypeCode create_struct_tc(String id, String name, 620 StructMember[] members 621 ); 622 623 /** 624 * Create the typecode, defining the given IDL union. 625 * 626 * The TypeCode object is initialized with the given id, name, discriminator 627 * and members. 628 * 629 * @param id the Id of this type. 630 * @param name the name of this type. 631 * @param discriminator the union discriminator. 632 * @param members the member list. 633 * 634 * @return the typecode. 635 */ create_union_tc(String id, String name, TypeCode discriminator, UnionMember[] members )636 public abstract TypeCode create_union_tc(String id, String name, 637 TypeCode discriminator, 638 UnionMember[] members 639 ); 640 641 /** 642 * Create a TypeCode, representing the CORBA <code>wstring</code>. 643 * 644 * @param bound the maximal length of the string, 0 is unlimited. 645 * 646 * @return the corresponding string typecode. 647 */ create_wstring_tc(int bound)648 public abstract TypeCode create_wstring_tc(int bound); 649 650 /** 651 * Create a typecode for an abstract interface. The abstract interface 652 * can be either CORBA object or CORBA value type. 653 * 654 * @param id the id of the abstract interface. 655 * @param name the name of the abstract interface. 656 * 657 * @return the created typecode. 658 */ create_abstract_interface_tc(String id, String name)659 public TypeCode create_abstract_interface_tc(String id, String name) 660 { 661 GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_abstract_interface); 662 t.setName(name); 663 t.setId(id); 664 return t; 665 } 666 667 /** 668 * Create a typecode for a native interface. 669 * 670 * @param id the id of the native interface. 671 * @param name the name of the native interface. 672 * 673 * @return the created typecode. 674 */ create_native_tc(String id, String name)675 public TypeCode create_native_tc(String id, String name) 676 { 677 GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_native); 678 t.setName(name); 679 t.setId(id); 680 return t; 681 } 682 683 684 /** 685 * Create a typecode which serves as a placeholder for typcode, containing 686 * recursion. 687 * 688 * @param id the id of the recursive typecode, for that this typecode 689 * serves as a placeholder. 690 */ create_recursive_tc(String id)691 public TypeCode create_recursive_tc(String id) 692 { 693 return new RecursiveTypeCode(id); 694 } 695 696 /** 697 * Create value box typecode. 698 */ create_value_box_tc(String id, String name, TypeCode boxed_type )699 public TypeCode create_value_box_tc(String id, String name, 700 TypeCode boxed_type 701 ) 702 { 703 GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_value_box); 704 t.setName(name); 705 t.setId(id); 706 t.setContentType(boxed_type); 707 return t; 708 } 709 710 /** 711 * Create IDL value type code. 712 */ create_value_tc(String id, String name, short type_modifier, TypeCode concrete_base, ValueMember[] members )713 public TypeCode create_value_tc(String id, String name, short type_modifier, 714 TypeCode concrete_base, ValueMember[] members 715 ) 716 { 717 RecordTypeCode r = new RecordTypeCode(TCKind.tk_value); 718 r.setId(id); 719 r.setName(name); 720 r.setTypeModifier(type_modifier); 721 r.setConcreteBase_type(concrete_base); 722 723 for (int i = 0; i < members.length; i++) 724 { 725 r.add(members [ i ]); 726 } 727 728 return r; 729 } 730 731 /** 732 * This should return the information, related to the current thread. 733 * The information is needed, for instance, to get the current object 734 * from the code that serves several objects in parallel threads. 735 * The {@link Current} is very general interface, with no fields and 736 * operations defined. This method is not implemented in Suns 737 * releases at least till v1.5 inclusive. To obtain the 738 * {@link org.omg.PortableServer.Current}, use 739 * {@link #resolve_initial_references}, passing "POACurrent". 740 * 741 * @deprecated since 1.2, use {@link #resolve_initial_references}. 742 * 743 * @return never 744 * 745 * @throws NO_IMPLEMENT always. 746 */ get_current()747 public Current get_current() 748 { 749 throw new NO_IMPLEMENT(); 750 } 751 752 /** 753 * This should return the information about the CORBA facilities and 754 * services, available from this ORB. However this method is oficially 755 * documented as not implemented at least till v1.5 inclusive. 756 * 757 * @param service_type a type of the service being requested. The OMG 758 * specification currently defines only one value, 1, for security 759 * related services. 760 * 761 * @param service_info a holder, where the returned information should 762 * be stored. 763 * 764 * @return should return true if the service information is available 765 * from the ORB, but this method never returns. 766 * 767 * @throws NO_IMPLEMENT always. 768 */ get_service_information(short service_type, ServiceInformationHolder service_info )769 public boolean get_service_information(short service_type, 770 ServiceInformationHolder service_info 771 ) 772 { 773 throw new NO_IMPLEMENT(); 774 } 775 776 /** 777 * Get the default context of this ORB. This is an initial root of all 778 * contexts. 779 * 780 * The default method returns a new context with the empty name and 781 * no parent context. 782 * 783 * @return the default context of this ORB. 784 * 785 * @throws NO_IMPLEMENT for the Singleton ORB, returned by 786 * the parameterless {@link #init()}. 787 */ get_default_context()788 public abstract Context get_default_context(); 789 790 /** 791 * Return thg typecode, representing the given primitive object type. 792 * 793 * @param tcKind the kind of the primitive typecode. 794 * 795 * @return the typecode of the primitve typecode. 796 */ get_primitive_tc(TCKind tcKind)797 public abstract TypeCode get_primitive_tc(TCKind tcKind); 798 799 /** 800 * Returns so-called Singleton ORB, a highly restricted version 801 * that cannot communicate over network. This ORB is provided 802 * for the potentially malicious applets with heavy security restrictions. 803 * 804 * The returned Singleton ORB can only create typecodes, 805 * {@link Any}, {@link ContextList}, {@link NVList} and 806 * {@link org.omg.CORBA.portable.OutputStream} that writes to an 807 * internal buffer. 808 * 809 * All other methods throw the {@link NO_IMPLEMENT} exception, additionally 810 * printing the error message about the potential attempt to violate 811 * the security rules. 812 * 813 * The implementing ORB class, used in this method, is found as described 814 * in the header. 815 * 816 * @return the working derivative of ORB, implementing the methods 817 * of this abstract class. 818 */ init()819 public static ORB init() 820 { 821 String orb_cn = getCumulatedProperty(null, RESTRICTED_ORB); 822 if (orb_cn == null) 823 return OrbRestricted.Singleton; 824 else 825 return createORB(null, orb_cn); 826 } 827 828 /** 829 * Creates the working instance of ORB for an applet. 830 * 831 * By default the built-in fully functional ORB is returned. The ORB class 832 * is found as described in the header of this class. 833 * 834 * @param applet the applet. The property org.omg.CORBA.ORBClass, 835 * if present, defines the used ORB implementation class. If this 836 * property is not present, the ORB class is found as described in the 837 * class header. 838 * 839 * @param props the properties, may be <code>null</code>. 840 * 841 * @return a newly created functional derivative of this abstract class. 842 */ init(Applet applet, Properties props)843 public static ORB init(Applet applet, Properties props) 844 { 845 String ocn = applet.getParameter(FUNCTIONAL_ORB); 846 String lp = applet.getParameter(LISTENER_PORT); 847 848 if (ocn==null && lp!=null) 849 ocn = DEFAULT_FOCUSED_ORB; 850 851 ORB orb = createORB(props, ocn); 852 orb.set_parameters(applet, props); 853 854 return orb; 855 } 856 857 /** 858 * Creates the working instance of ORB for a standalone application. 859 * 860 * By default the built-in fully functional ORB is returned. The ORB class is 861 * found as described in the header of this class. 862 * 863 * @param args the parameters, passed to the applications 864 * <code>main(String[] args)</code> method, may be <code>null</code>. The 865 * parameter -org.omg.CORBA.ORBClass <class name> if present, defines the used 866 * ORB implementation class. If this property is not present, the ORB class is 867 * found as described in the class header. 868 * 869 * @param props application specific properties, may be <code>null</code>. 870 * 871 * @return a newly created functional derivative of this abstract class. 872 */ init(String[] args, Properties props)873 public static ORB init(String[] args, Properties props) 874 { 875 String ocn = null; 876 String lp = null; 877 878 String orbKey = "-" + FUNCTIONAL_ORB; 879 String lpKey = "-" + LISTENER_PORT; 880 881 if (args != null) 882 if (args.length >= 2) 883 { 884 for (int i = 0; i < args.length - 1; i++) 885 { 886 if (args[i].equals(orbKey)) 887 ocn = args[i + 1]; 888 if (args[i].equals(lpKey)) 889 lp = args[i + 1]; 890 } 891 } 892 893 if (lp != null && ocn == null) 894 ocn = DEFAULT_FOCUSED_ORB; 895 896 ORB orb = createORB(props, ocn); 897 898 orb.set_parameters(args, props); 899 return orb; 900 } 901 902 /** 903 * List the initially available CORBA objects (services). 904 * 905 * @return a list of services. 906 * 907 * @see #resolve_initial_references(String) 908 */ list_initial_services()909 public abstract String[] list_initial_services(); 910 911 /** 912 * Find and return the easily accessible CORBA object, addressed 913 * by name. The returned object is typically casted to the more 914 * specific reference using the <code>narrow(Object)</code> method 915 * of its helper. The method resolves the following string values, 916 * returning the working objects: 917 * <table border="1"><tr><th>String</th><th>Object class</th> 918 * <th>Object use</th></tr> 919 * 920 * <tr><td>NameService</td><td>{@link org.omg.CosNaming.NamingContextExt}</td> 921 * <td>Finds (usually remote) object by its name.</td></tr> 922 * 923 * <tr><td>RootPOA</td><td>{@link org.omg.PortableServer.POA}</td> 924 * <td>Holds the POA tree for this ORB, where since 1.4 all servants 925 * should be connected.</td></tr> 926 * 927 * <tr><td>RootPOAManager</td><td>{@link org.omg.PortableServer.POAManager} 928 * </td><td>Regulates (suspends/resumes) the root POA 929 * activity</td></tr> 930 * 931 * <tr><td>POACurrent</td><td>{@link org.omg.PortableServer.Current} 932 * </td><td>Informs the current thread about the Id and POA of the 933 * object being currently served (the methods of 934 * <code>Current</code> return different values for 935 * different threads). 936 * </td></tr> 937 * 938 * <tr><td>CodecFactory</td><td>{@link org.omg.IOP.Codec}</td> 939 * <td>Encodes/decodes IDL data types into/from byte arrays.</td> 940 * </tr> 941 * 942 * <tr><td>DynAnyFactory</td><td>{@link org.omg.DynamicAny.DynAnyFactory}</td> 943 * <td>Creates DynAny's.</td> 944 * </tr> 945 * 946 * <tr><td>PICurrent</td><td>{@link org.omg.PortableInterceptor.Current}</td> 947 * <td>Contains multiple slots where an interceptor can rememeber the 948 * request - specific values between subsequent 949 * calls of the interceptor methods.</td> 950 * </tr> 951 * 952 * </table> 953 * 954 * @param name the object name. 955 * @return the object 956 * @throws org.omg.CORBA.ORBPackage.InvalidName if the given name 957 * is not associated with the known object. 958 */ resolve_initial_references(String name)959 public abstract Object resolve_initial_references(String name) 960 throws org.omg.CORBA.ORBPackage.InvalidName; 961 962 /** 963 * Get the IOR reference string for the given object. 964 * IOR can be compared with the Internet address for a web page, 965 * it provides means to locate the CORBA service on the web. 966 * IOR contains the host address, port number, the object identifier 967 * (key) inside the server, the communication protocol version, 968 * supported charsets and so on. 969 * 970 * @param forObject the CORBA object 971 * @return the object IOR representation. 972 * @see #string_to_object(String) 973 */ object_to_string(Object forObject)974 public abstract String object_to_string(Object forObject); 975 976 /** 977 * This should perform the implementation dependent unit of work in the 978 * main thread. 979 * 980 * This method is part of the support for the distribute use of the 981 * single execution thread. 982 * 983 * Same as in Suns releases at least till 1.4 inclusive, 984 * the distribute use of the single thread is not implemented. 985 * Use multiple threads, provided by jre. 986 * 987 * The method returns without action. 988 */ perform_work()989 public void perform_work() 990 { 991 } 992 993 /** 994 * Checks if the ORB needs the main thread to perform some work. 995 * The method should return true if the ORB needs the main thread, 996 * and false if it does not. 997 * 998 * This method is part of the support for the distribute use of the 999 * single execution thread. 1000 * 1001 * Same as in Suns releases at least till 1.4 inclusive, 1002 * the distributed use of the single thread is not implemented. 1003 * Use multiple threads, provided by jre. 1004 * 1005 * @return false, always. 1006 */ work_pending()1007 public boolean work_pending() 1008 { 1009 return false; 1010 } 1011 1012 /** 1013 * <p>Find and return the CORBA object, addressed by the given 1014 * string representation. The object can be (an usually is) 1015 * located on a remote computer, possibly running a different 1016 * (not necessary java) CORBA implementation. The returned 1017 * object is typically casted to the more specific reference 1018 * using the <code>narrow(Object)</code> method of its helper. 1019 * </p><p> 1020 * This function supports the following input formats:<br> 1021 * 1. IOR reference (<b>ior:</b>nnnnn ..), usually computer generated.<br> 1022 * 2. <b>corbaloc:</b>[<b>iiop</b>][version.subversion<b>@</b>]<b>:</b>host[<b>:</b>port]<b>/</b><i>key</i> 1023 * defines similar information as IOR reference, but is more human readable. 1024 * This type of reference may also contain multiple addresses (see 1025 * OMG documentation for complete format).<br> 1026 * 3. <b>corbaloc:rir:/</b><i>name</i> defines internal reference on this 1027 * ORB that is resolved using {@link #resolve_initial_references}, passing 1028 * the given <i>name</i> as parameter.<br> 1029 * 4. <b>corbaname:rir:#</b><i>name</i> states that the given <i>name</i> 1030 * must be resolved using the naming service, default for this ORB.<br> 1031 * 5. <b>corbaname:</b>[<b>iiop</b>][version.subversion<b>@</b>]<b>:</b>host[<b>:</b>port]<b>#</b><i>name</i> 1032 * states that the <i>name</i> must be resolved using the naming service 1033 * that runs on the given host at the given port. The ORB expects to find 1034 * there the {@link org.omg.CosNaming.NamingContext} under the key 1035 * "NameService.<br> 1036 * 7. file://[file name] Read the object definition string from the 1037 * file system<br> 1038 * 8. http://[url] Read the object definition string from the provided 1039 * url.<br> 1040 * 9. ftp://[url] Read the object definition string from the provided 1041 * url.<br> 1042 * 1043 * <p>The default port is always 2809. The default iiop version is 1.0 1044 * that now may not always be supported, so we would recommend to specify 1045 * the version explicitly.</p> 1046 * <p> 1047 * The examples of the corbaloc and corbaname addresses:<br> 1048 * corbaname:rir:#xobj - ask local naming service for "xobj".<br> 1049 * corbaname:rir:/NameService#xobj - same (long form).<br> 1050 * corbaname:iiop:1.2@localhost:900#xobj - same, assuming that the naming 1051 * service runs at port 900 on the local host and supports iiop 1.2.<br> 1052 * corbaname:iiop:localhost#xobj - same, assuming that the naming 1053 * service runs at port 2809 on the local host and supports iiop 1.0.<br> 1054 * corbaloc::gnu.xxx.yy/Prod/TradingService - the object exists on the 1055 * host gnu.xxx.yy, port 2809 having the key "Prod/TradingService". Its ORB 1056 * supports iiop 1.0.<br> 1057 * corbaloc::gnu.xxx.yy/Prod/TradingService:801 - the object exists on the 1058 * host gnu.xxx.yy, port 801 having the key "Prod/TradingService". Its ORB 1059 * supports iiop 1.0 (iiop keyword ommitted).<br> 1060 * corbaloc:iiop:1.1@gnu.xxx.yy/Prod/TradingService - the object exists on the 1061 * host gnu.xxx.yy, port 801 having the key "Prod/TradingService". Its ORB 1062 * supports iiop 1.1.<br> 1063 * corbaloc:rir:/NameService - the default naming service. 1064 * 1065 * @param IOR the object IOR representation string. 1066 * 1067 * @return the found CORBA object. 1068 * 1069 * @throws BAD_PARAM if the string being parsed is invalid. 1070 * @throws DATA_CONVERSION if the string being parsed contains unsupported 1071 * prefix or protocol. 1072 * 1073 * @see #object_to_string(org.omg.CORBA.Object) 1074 */ string_to_object(String IOR)1075 public abstract Object string_to_object(String IOR); 1076 1077 /** 1078 * Start listening on the input socket. This method 1079 * blocks the current thread until {@link #shutdown(boolean)} 1080 * is called and shutdown process is completed. 1081 */ run()1082 public void run() 1083 { 1084 } 1085 1086 /** 1087 * Shutdown the ORB server. 1088 * 1089 * @param wait_for_completion if true, the current thread is 1090 * suspended untile the shutdown process is complete. 1091 */ shutdown(boolean wait_for_completion)1092 public void shutdown(boolean wait_for_completion) 1093 { 1094 } 1095 1096 /** 1097 * Destroy this server, releasing the occupied resources. 1098 * The default method returns without action. 1099 */ destroy()1100 public void destroy() 1101 { 1102 } 1103 1104 /** 1105 * Set the ORB parameters. This method is normally called from 1106 * {@link #init(String[], Properties)}. 1107 * 1108 * @param para the parameters, that were passed as the parameters 1109 * to the <code>main(String[] args)</code> method of the current standalone 1110 * application. 1111 * 1112 * @param props application specific properties that were passed 1113 * as a second parameter in {@link #init(String[], Properties)}). 1114 * Can be <code>null</code>. 1115 */ set_parameters(String[] para, Properties props)1116 protected abstract void set_parameters(String[] para, Properties props); 1117 1118 /** 1119 * Set the ORB parameters. This method is normally called from 1120 * {@link #init(Applet, Properties)}. 1121 * 1122 * @param app the current applet. 1123 * 1124 * @param props application specific properties, passed as the second 1125 * parameter in {@link #init(Applet, Properties)}. 1126 * Can be <code>null</code>. 1127 */ set_parameters(Applet app, Properties props)1128 protected abstract void set_parameters(Applet app, Properties props); 1129 1130 /** 1131 * Get the property with the given name, searching in the standard 1132 * places for the ORB properties. 1133 */ getCumulatedProperty(Properties props, String property)1134 private static String getCumulatedProperty(Properties props, String property) 1135 { 1136 String orb_cn = null; 1137 1138 if (props != null) 1139 orb_cn = props.getProperty(property, null); 1140 1141 if (orb_cn == null) 1142 orb_cn = System.getProperty(property, null); 1143 1144 if (orb_cn == null) 1145 orb_cn = checkFile(property, "user.home", null); 1146 1147 if (orb_cn == null) 1148 orb_cn = checkFile(property, "java.home", "lib"); 1149 1150 return orb_cn; 1151 } 1152 1153 /** 1154 * Check if the property is defined in the existsting file orb.properties. 1155 * 1156 * @param property the property 1157 * @param dir the system property, defining the folder where the 1158 * file could be expected. 1159 * @param subdir subfolder where to look for the file. 1160 * 1161 * @return the property value, null if not found or file does not exist. 1162 */ checkFile(String property, String dir, String subdir)1163 private static String checkFile(String property, String dir, String subdir) 1164 { 1165 try 1166 { 1167 File f = new File(dir); 1168 if (!f.exists()) 1169 return null; 1170 1171 if (subdir != null) 1172 f = new File(f, subdir); 1173 1174 f = new File(f, "orb.properties"); 1175 1176 if (!f.exists()) 1177 return null; 1178 1179 Properties p = new Properties(); 1180 p.load(new BufferedInputStream(new FileInputStream(f))); 1181 1182 return p.getProperty(property, null); 1183 } 1184 catch (IOException ex) 1185 { 1186 return null; 1187 } 1188 } 1189 1190 /** 1191 * Create ORB when its name is possibly known. 1192 * 1193 * @param props properties, possibly containing the ORB name. 1194 * @param orbClassName the direct ORB class name, overriding other possible 1195 * locations, or null if not specified. 1196 */ createORB(Properties props, String orbClassName)1197 private static ORB createORB(Properties props, String orbClassName) 1198 { 1199 ORB orb = null; 1200 1201 if (orbClassName == null) 1202 { 1203 orbClassName = getCumulatedProperty(props, FUNCTIONAL_ORB); 1204 1205 if (orbClassName == null) 1206 { 1207 String lp = getCumulatedProperty(props, LISTENER_PORT); 1208 if (lp != null) 1209 orbClassName = DEFAULT_FOCUSED_ORB; 1210 else 1211 orbClassName = DEFAULT_FUNCTIONAL_ORB; 1212 } 1213 } 1214 1215 try 1216 { 1217 orb = (ORB) ObjectCreator.forName(orbClassName).newInstance(); 1218 } 1219 catch (ClassNotFoundException ex) 1220 { 1221 noORB(orbClassName, ex); 1222 } 1223 catch (IllegalAccessException ex) 1224 { 1225 noORB(orbClassName, ex); 1226 } 1227 catch (InstantiationException ex) 1228 { 1229 noORB(orbClassName, ex); 1230 } 1231 1232 return orb; 1233 } 1234 1235 /** 1236 * Throw the runtime exception. 1237 * 1238 * @param orb_c the ORB class name. 1239 * @param why the explaining chained exception. 1240 */ noORB(String orb_c, Throwable why)1241 private static void noORB(String orb_c, Throwable why) 1242 { 1243 throw new RuntimeException("The ORB " + orb_c + " cannot be instantiated.", 1244 why 1245 ); 1246 } 1247 } 1248