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 */ OrbRestricted()135 protected OrbRestricted() 136 { 137 } 138 139 /** {@inheritDoc} */ create_alias_tc(String id, String name, TypeCode typecode)140 public TypeCode create_alias_tc(String id, String name, TypeCode typecode) 141 { 142 return new AliasTypeCode(typecode, id, name); 143 } 144 145 /** {@inheritDoc} */ create_any()146 public Any create_any() 147 { 148 gnuAny any = new gnuAny(); 149 any.setOrb(this); 150 return any; 151 } 152 153 /** {@inheritDoc} */ create_array_tc(int length, TypeCode element_type)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} */ create_context_list()163 public ContextList create_context_list() 164 { 165 return new gnuContextList(); 166 } 167 168 /** {@inheritDoc} */ create_enum_tc(String id, String name, String[] values)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} */ create_environment()184 public Environment create_environment() 185 { 186 return new gnuEnvironment(); 187 } 188 189 /** {@inheritDoc} */ create_exception_list()190 public ExceptionList create_exception_list() 191 { 192 return new gnuExceptionList(); 193 } 194 195 /** {@inheritDoc} */ create_exception_tc(String id, String name, StructMember[] members )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 */ create_interface_tc(String id, String name)217 public TypeCode create_interface_tc(String id, String name) 218 { 219 no(); 220 return null; 221 } 222 223 /** {@inheritDoc} */ create_list(int count)224 public NVList create_list(int count) 225 { 226 return new gnuNVList(count); 227 } 228 229 /** {@inheritDoc} */ create_named_value(String s, Any any, int flags)230 public NamedValue create_named_value(String s, Any any, int flags) 231 { 232 return new gnuNamedValue(); 233 } 234 235 /** {@inheritDoc} */ create_output_stream()236 public OutputStream create_output_stream() 237 { 238 BufferedCdrOutput stream = new BufferedCdrOutput(); 239 stream.setOrb(this); 240 return stream; 241 } 242 243 /** {@inheritDoc} */ create_sequence_tc(int bound, TypeCode element_type)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} */ create_string_tc(int bound)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} */ create_struct_tc(String id, String name, StructMember[] members )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} */ create_union_tc(String id, String name, TypeCode discriminator_type, UnionMember[] members )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} */ create_wstring_tc(int bound)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} */ get_primitive_tc(TCKind tcKind)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 */ list_initial_services()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 */ object_to_string(org.omg.CORBA.Object forObject)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 */ resolve_initial_references(String name)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 */ run()361 public void run() 362 { 363 } 364 365 /** 366 * Shutdown the ORB server. 367 * 368 * For RestrictedORB, returns witout action. 369 */ shutdown(boolean wait_for_completion)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 */ string_to_object(String IOR)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 */ set_parameters(Applet app, Properties props)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 */ set_parameters(String[] args, Properties props)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 */ no()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 */ get_next_response()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 */ poll_next_response()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 */ send_multiple_requests_deferred(Request[] requests)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 */ send_multiple_requests_oneway(Request[] requests)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 */ register_value_factory(String repository_id, ValueFactory factory )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 */ unregister_value_factory(String id)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 */ lookup_value_factory(String repository_id)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 */ destroy()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 */ create_recursive_sequence_tc(int bound, int offset)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 */ get_default_context()578 public Context get_default_context() 579 { 580 return new gnuContext("", null); 581 } 582 583 } 584