Source for gnu.CORBA.OrbRestricted

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