libjava/classpath/gnu/CORBA/OrbRestricted.java

   1 /* RestrictedORB.java --
   2    Copyright (C) 2005 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 gnu.CORBA;
  40
  41 import gnu.CORBA.CDR.BufferedCdrOutput;
  42 import gnu.CORBA.typecodes.AliasTypeCode;
  43 import gnu.CORBA.typecodes.ArrayTypeCode;
  44 import gnu.CORBA.typecodes.PrimitiveTypeCode;
  45 import gnu.CORBA.typecodes.RecordTypeCode;
  46 import gnu.CORBA.typecodes.StringTypeCode;
  47
  48 import org.omg.CORBA.Any;
  49 import org.omg.CORBA.BAD_PARAM;
  50 import org.omg.CORBA.Context;
  51 import org.omg.CORBA.ContextList;
  52 import org.omg.CORBA.Environment;
  53 import org.omg.CORBA.ExceptionList;
  54 import org.omg.CORBA.NO_IMPLEMENT;
  55 import org.omg.CORBA.NVList;
  56 import org.omg.CORBA.NamedValue;
  57 import org.omg.CORBA.ORB;
  58 import org.omg.CORBA.ORBPackage.InvalidName;
  59 import org.omg.CORBA.Request;
  60 import org.omg.CORBA.StructMember;
  61 import org.omg.CORBA.TCKind;
  62 import org.omg.CORBA.TypeCode;
  63 import org.omg.CORBA.TypeCodePackage.BadKind;
  64 import org.omg.CORBA.UnionMember;
  65 import org.omg.CORBA.portable.OutputStream;
  66 import org.omg.CORBA.portable.ValueFactory;
  67 import org.omg.PortableInterceptor.ClientRequestInterceptorOperations;
  68 import org.omg.PortableInterceptor.IORInterceptorOperations;
  69 import org.omg.PortableInterceptor.IORInterceptor_3_0Operations;
  70 import org.omg.PortableInterceptor.ServerRequestInterceptorOperations;
  71
  72 import java.applet.Applet;
  73
  74 import java.util.Hashtable;
  75 import java.util.Properties;
  76
  77 /**
  78  * This class implements so-called Singleton ORB, a highly restricted version
  79  * that cannot communicate over network. This ORB is provided for the
  80  * potentially malicious applets with heavy security restrictions. It, however,
  81  * supports some basic features that might be needed even when the network
  82  * access is not granted.
  83  *
  84  * This ORB can only create typecodes, {@link Any}, {@link ContextList},
  85  * {@link NVList} and {@link org.omg.CORBA.portable.OutputStream} that writes to
  86  * an internal buffer.
  87  *
  88  * All other methods throw the {@link NO_IMPLEMENT} exception.
  89  *
  90  * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
  91  */
  92 public class OrbRestricted extends org.omg.CORBA_2_3.ORB
  93 {
  94   /**
  95    * The singleton instance of this ORB.
  96    */
  97   public static final ORB Singleton = new OrbRestricted();
  98
  99   /**
 100    * The cumulated listener for all IOR interceptors. Interceptors are used by
 101    * {@link gnu.CORBA.Poa.ORB_1_4}.
 102    */
 103   public IORInterceptor_3_0Operations iIor;
 104
 105   /**
 106    * The cumulated listener for all server request interceptors. Interceptors
 107    * are used by {@link gnu.CORBA.Poa.ORB_1_4}.
 108    */
 109   public ServerRequestInterceptorOperations iServer;
 110
 111   /**
 112    * The cumulated listener for all client request interceptros. Interceptors
 113    * are used by {@link gnu.CORBA.Poa.ORB_1_4}.
 114    */
 115   public ClientRequestInterceptorOperations iClient;
 116
 117   /**
 118    * The required size of the interceptor slot array.
 119    */
 120   public int icSlotSize = 0;
 121
 122   /**
 123    * The value factories.
 124    */
 125   protected Hashtable factories = new Hashtable();
 126
 127   /**
 128    * The policy factories.
 129    */
 130   protected Hashtable policyFactories = new Hashtable();
 131
 132   /**
 133        * Create a new instance of the RestrictedORB. This is used in derived classes
 134    * only.
 135    */
 136   protected OrbRestricted()
 137   {
 138   }
 139
 140   /** {@inheritDoc} */
 141   public TypeCode create_alias_tc(String id, String name, TypeCode typecode)
 142   {
 143     return new AliasTypeCode(typecode, id, name);
 144   }
 145
 146   /** {@inheritDoc} */
 147   public Any create_any()
 148   {
 149     gnuAny any = new gnuAny();
 150     any.setOrb(this);
 151     return any;
 152   }
 153
 154   /** {@inheritDoc} */
 155   public TypeCode create_array_tc(int length, TypeCode element_type)
 156   {
 157     ArrayTypeCode p =
 158       new ArrayTypeCode(TCKind.tk_array, element_type);
 159     p.setLength(length);
 160     return p;
 161   }
 162
 163   /** {@inheritDoc} */
 164   public ContextList create_context_list()
 165   {
 166     return new gnuContextList();
 167   }
 168
 169   /** {@inheritDoc} */
 170   public TypeCode create_enum_tc(String id, String name, String[] values)
 171   {
 172     RecordTypeCode r = new RecordTypeCode(TCKind.tk_enum);
 173     for (int i = 0; i < values.length; i++)
 174       {
 175         r.field().name = values [ i ];
 176       }
 177
 178     r.setId(id);
 179     r.setName(name);
 180
 181     return r;
 182   }
 183
 184   /** {@inheritDoc} */
 185   public Environment create_environment()
 186   {
 187     return new gnuEnvironment();
 188   }
 189
 190   /** {@inheritDoc} */
 191   public ExceptionList create_exception_list()
 192   {
 193     return new gnuExceptionList();
 194   }
 195
 196   /** {@inheritDoc} */
 197   public TypeCode create_exception_tc(String id, String name,
 198     StructMember[] members
 199   )
 200   {
 201     RecordTypeCode r = new RecordTypeCode(TCKind.tk_except);
 202     r.setId(id);
 203     r.setName(name);
 204
 205     for (int i = 0; i < members.length; i++)
 206       {
 207         r.add(members [ i ]);
 208       }
 209
 210     return r;
 211   }
 212
 213   /**
 214    * This method is not allowed for a RestrictedORB.
 215    *
 216    * @throws NO_IMPLEMENT, always.
 217    */
 218   public TypeCode create_interface_tc(String id, String name)
 219   {
 220     no();
 221     return null;
 222   }
 223
 224   /** {@inheritDoc} */
 225   public NVList create_list(int count)
 226   {
 227     return new gnuNVList(count);
 228   }
 229
 230   /** {@inheritDoc} */
 231   public NamedValue create_named_value(String s, Any any, int flags)
 232   {
 233     return new gnuNamedValue();
 234   }
 235
 236   /** {@inheritDoc} */
 237   public OutputStream create_output_stream()
 238   {
 239     BufferedCdrOutput stream = new BufferedCdrOutput();
 240     stream.setOrb(this);
 241     return stream;
 242   }
 243
 244   /** {@inheritDoc} */
 245   public TypeCode create_sequence_tc(int bound, TypeCode element_type)
 246   {
 247     ArrayTypeCode p =
 248       new ArrayTypeCode(TCKind.tk_sequence, element_type);
 249     p.setLength(bound);
 250     return p;
 251   }
 252
 253   /** {@inheritDoc} */
 254   public TypeCode create_string_tc(int bound)
 255   {
 256     StringTypeCode p = new StringTypeCode(TCKind.tk_string);
 257     p.setLength(bound);
 258     return p;
 259   }
 260
 261   /** {@inheritDoc} */
 262   public TypeCode create_struct_tc(String id, String name,
 263     StructMember[] members
 264   )
 265   {
 266     RecordTypeCode r = new RecordTypeCode(TCKind.tk_struct);
 267     r.setId(id);
 268     r.setName(name);
 269
 270     for (int i = 0; i < members.length; i++)
 271       {
 272         r.add(members [ i ]);
 273       }
 274
 275     return r;
 276   }
 277
 278   /** {@inheritDoc} */
 279   public TypeCode create_union_tc(String id, String name,
 280     TypeCode discriminator_type, UnionMember[] members
 281   )
 282   {
 283     RecordTypeCode r = new RecordTypeCode(TCKind.tk_union);
 284     r.setId(id);
 285     r.setName(name);
 286     r.setDiscriminator_type(discriminator_type);
 287     r.setDefaultIndex(0);
 288
 289     for (int i = 0; i < members.length; i++)
 290       {
 291         r.add(members [ i ]);
 292       }
 293
 294     return r;
 295   }
 296
 297   /** {@inheritDoc} */
 298   public TypeCode create_wstring_tc(int bound)
 299   {
 300     StringTypeCode p = new StringTypeCode(TCKind.tk_wstring);
 301     p.setLength(bound);
 302     return p;
 303   }
 304
 305   /** {@inheritDoc} */
 306   public TypeCode get_primitive_tc(TCKind tcKind)
 307   {
 308     try
 309       {
 310         return TypeKindNamer.getPrimitveTC(tcKind);
 311       }
 312     catch (BadKind ex)
 313       {
 314         throw new BAD_PARAM("This is not a primitive type code: " +
 315           tcKind.value()
 316         );
 317       }
 318   }
 319
 320   /**
 321    * This method is not allowed for a RestrictedORB.
 322    *
 323    * @throws NO_IMPLEMENT, always.
 324    */
 325   public String[] list_initial_services()
 326   {
 327     no();
 328     throw new InternalError();
 329   }
 330
 331   /**
 332    * This method is not allowed for a RestrictedORB.
 333    *
 334    * @throws NO_IMPLEMENT, always.
 335    */
 336   public String object_to_string(org.omg.CORBA.Object forObject)
 337   {
 338     no();
 339     throw new InternalError();
 340   }
 341
 342   /**
 343    * This method is not allowed for a RestrictedORB.
 344    *
 345    * @throws InvalidName never in this class, but it is thrown in the derived
 346    * classes.
 347    *
 348    * @throws NO_IMPLEMENT, always.
 349    */
 350   public org.omg.CORBA.Object resolve_initial_references(String name)
 351     throws InvalidName
 352   {
 353     no();
 354     throw new InternalError();
 355   }
 356
 357   /**
 358    * Shutdown the ORB server.
 359    *
 360    * For RestrictedORB, returns witout action.
 361    */
 362   public void run()
 363   {
 364   }
 365
 366   /**
 367    * Shutdown the ORB server.
 368    *
 369    * For RestrictedORB, returns witout action.
 370    */
 371   public void shutdown(boolean wait_for_completion)
 372   {
 373   }
 374
 375   /**
 376    * This method is not allowed for a RestrictedORB.
 377    *
 378    * @throws NO_IMPLEMENT, always.
 379    */
 380   public org.omg.CORBA.Object string_to_object(String IOR)
 381   {
 382     no();
 383     throw new InternalError();
 384   }
 385
 386   /**
 387    * This method is not allowed for a RestrictedORB.
 388    *
 389    * @throws NO_IMPLEMENT, always.
 390    */
 391   protected void set_parameters(Applet app, Properties props)
 392   {
 393     no();
 394   }
 395
 396   /**
 397    * This method is not allowed for a RestrictedORB.
 398    *
 399    * @throws NO_IMPLEMENT, always.
 400    */
 401   protected void set_parameters(String[] args, Properties props)
 402   {
 403     no();
 404   }
 405
 406   /**
 407    * Throws an exception, stating that the given method is not supported by the
 408    * Restricted ORB.
 409    */
 410   private final void no()
 411   {
 412     // Apart the programming errors, this can only happen if the
 413     // malicious code is trying to do that it is not allowed.
 414     throw new NO_IMPLEMENT("Use init(args, props) for the functional version.");
 415   }
 416
 417   /**
 418    * This method is not allowed for a RestrictedORB.
 419    *
 420    * @throws NO_IMPLEMENT, always.
 421    */
 422   public Request get_next_response() throws org.omg.CORBA.WrongTransaction
 423   {
 424     no();
 425     throw new InternalError();
 426   }
 427
 428   /**
 429    * This method is not allowed for a RestrictedORB.
 430    *
 431    * @throws NO_IMPLEMENT, always.
 432    */
 433   public boolean poll_next_response()
 434   {
 435     no();
 436     throw new InternalError();
 437   }
 438
 439   /**
 440    * This method is not allowed for a RestrictedORB.
 441    *
 442    * @throws NO_IMPLEMENT, always.
 443    */
 444   public void send_multiple_requests_deferred(Request[] requests)
 445   {
 446     no();
 447   }
 448
 449   /**
 450    * This method is not allowed for a RestrictedORB.
 451    *
 452    * @throws NO_IMPLEMENT, always.
 453    */
 454   public void send_multiple_requests_oneway(Request[] requests)
 455   {
 456     no();
 457   }
 458
 459   /**
 460    * Register the value factory under the given repository id.
 461    */
 462   public ValueFactory register_value_factory(String repository_id,
 463     ValueFactory factory
 464   )
 465   {
 466     factories.put(repository_id, factory);
 467     return factory;
 468   }
 469
 470   /**
 471    * Unregister the value factroy.
 472    */
 473   public void unregister_value_factory(String id)
 474   {
 475     factories.remove(id);
 476   }
 477
 478   /**
 479    * Look for the value factory for the value, having the given repository id.
 480        * The implementation checks for the registered value factories first. If none
 481        * found, it tries to load and instantiate the class, mathing the given naming
 482    * convention. If this faild, null is returned.
 483    *
 484    * @param repository_id a repository id.
 485    *
 486    * @return a found value factory, null if none.
 487    */
 488   public ValueFactory lookup_value_factory(String repository_id)
 489   {
 490     ValueFactory f = (ValueFactory) factories.get(repository_id);
 491     if (f != null)
 492       {
 493         return f;
 494       }
 495
 496     f = (ValueFactory) ObjectCreator.createObject(repository_id,
 497         "DefaultFactory"
 498       );
 499     if (f != null)
 500       {
 501         factories.put(repository_id, f);
 502       }
 503     return f;
 504   }
 505
 506   /**
 507    * Destroy the interceptors, if they are present.
 508    */
 509   public void destroy()
 510   {
 511     if (iIor != null)
 512       {
 513         iIor.destroy();
 514         iIor = null;
 515       }
 516
 517     if (iServer != null)
 518       {
 519         iServer.destroy();
 520         iServer = null;
 521       }
 522
 523     if (iClient != null)
 524       {
 525         iClient.destroy();
 526         iClient = null;
 527       }
 528
 529     super.destroy();
 530   }
 531
 532   /**
 533    * Create a typecode, representing a tree-like structure.
 534    * This structure contains a member that is a sequence of the same type,
 535    * as the structure itself. You can imagine as if the folder definition
 536    * contains a variable-length array of the enclosed (nested) folder
 537    * definitions. In this way, it is possible to have a tree like
 538    * structure that can be transferred via CORBA CDR stream.
 539    *
 540    * @deprecated It is easier and clearler to use a combination of
 541    * create_recursive_tc and create_sequence_tc instead.
 542    *
 543    * @param bound the maximal expected number of the nested components
 544    * on each node; 0 if not limited.
 545    *
 546    * @param offset the position of the field in the returned structure
 547    * that contains the sequence of the structures of the same field.
 548    * The members before this field are intialised using parameterless
 549    * StructMember constructor.
 550    *
 551    * @return a typecode, defining a stucture, where a member at the
 552    * <code>offset</code> position defines an array of the identical
 553    * structures.
 554    *
 555    * @see #create_recursive_tc(String)
 556    * @see #create_sequence_tc(int, TypeCode)
 557    */
 558   public TypeCode create_recursive_sequence_tc(int bound, int offset)
 559   {
 560     RecordTypeCode r = new RecordTypeCode(TCKind.tk_struct);
 561     for (int i = 0; i < offset; i++)
 562       r.add(new StructMember());
 563
 564     TypeCode recurs = new PrimitiveTypeCode(TCKind.tk_sequence);
 565
 566     r.add(new StructMember("", recurs, null));
 567     return r;
 568   }
 569
 570   /**
 571    * Get the default context of this ORB. This is an initial root of all
 572    * contexts.
 573    *
 574    * The default method returns a new context with the empty name and
 575    * no parent context.
 576    *
 577    * @return the default context of this ORB.
 578    */
 579   public Context get_default_context()
 580   {
 581     return new gnuContext("", null);
 582   }
 583
 584 }