| /* RestrictedORB.java -- |
| Copyright (C) 2005 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package gnu.CORBA; |
| |
| import gnu.CORBA.CDR.BufferedCdrOutput; |
| import gnu.CORBA.typecodes.AliasTypeCode; |
| import gnu.CORBA.typecodes.ArrayTypeCode; |
| import gnu.CORBA.typecodes.PrimitiveTypeCode; |
| import gnu.CORBA.typecodes.RecordTypeCode; |
| import gnu.CORBA.typecodes.StringTypeCode; |
| |
| import org.omg.CORBA.Any; |
| import org.omg.CORBA.BAD_PARAM; |
| import org.omg.CORBA.Context; |
| import org.omg.CORBA.ContextList; |
| import org.omg.CORBA.Environment; |
| import org.omg.CORBA.ExceptionList; |
| import org.omg.CORBA.NO_IMPLEMENT; |
| import org.omg.CORBA.NVList; |
| import org.omg.CORBA.NamedValue; |
| import org.omg.CORBA.ORB; |
| import org.omg.CORBA.ORBPackage.InvalidName; |
| import org.omg.CORBA.Request; |
| import org.omg.CORBA.StructMember; |
| import org.omg.CORBA.TCKind; |
| import org.omg.CORBA.TypeCode; |
| import org.omg.CORBA.TypeCodePackage.BadKind; |
| import org.omg.CORBA.UnionMember; |
| import org.omg.CORBA.portable.OutputStream; |
| import org.omg.CORBA.portable.ValueFactory; |
| import org.omg.PortableInterceptor.ClientRequestInterceptorOperations; |
| import org.omg.PortableInterceptor.IORInterceptorOperations; |
| import org.omg.PortableInterceptor.IORInterceptor_3_0Operations; |
| import org.omg.PortableInterceptor.ServerRequestInterceptorOperations; |
| |
| import java.applet.Applet; |
| |
| import java.util.Hashtable; |
| import java.util.Properties; |
| |
| /** |
| * This class implements so-called Singleton ORB, a highly restricted version |
| * that cannot communicate over network. This ORB is provided for the |
| * potentially malicious applets with heavy security restrictions. It, however, |
| * supports some basic features that might be needed even when the network |
| * access is not granted. |
| * |
| * This ORB can only create typecodes, {@link Any}, {@link ContextList}, |
| * {@link NVList} and {@link org.omg.CORBA.portable.OutputStream} that writes to |
| * an internal buffer. |
| * |
| * All other methods throw the {@link NO_IMPLEMENT} exception. |
| * |
| * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) |
| */ |
| public class OrbRestricted extends org.omg.CORBA_2_3.ORB |
| { |
| /** |
| * The singleton instance of this ORB. |
| */ |
| public static final ORB Singleton = new OrbRestricted(); |
| |
| /** |
| * The cumulated listener for all IOR interceptors. Interceptors are used by |
| * {@link gnu.CORBA.Poa.ORB_1_4}. |
| */ |
| public IORInterceptor_3_0Operations iIor; |
| |
| /** |
| * The cumulated listener for all server request interceptors. Interceptors |
| * are used by {@link gnu.CORBA.Poa.ORB_1_4}. |
| */ |
| public ServerRequestInterceptorOperations iServer; |
| |
| /** |
| * The cumulated listener for all client request interceptros. Interceptors |
| * are used by {@link gnu.CORBA.Poa.ORB_1_4}. |
| */ |
| public ClientRequestInterceptorOperations iClient; |
| |
| /** |
| * The required size of the interceptor slot array. |
| */ |
| public int icSlotSize = 0; |
| |
| /** |
| * The value factories. |
| */ |
| protected Hashtable factories = new Hashtable(); |
| |
| /** |
| * The policy factories. |
| */ |
| protected Hashtable policyFactories = new Hashtable(); |
| |
| /** |
| * Create a new instance of the RestrictedORB. This is used in derived classes |
| * only. |
| */ |
| protected OrbRestricted() |
| { |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_alias_tc(String id, String name, TypeCode typecode) |
| { |
| return new AliasTypeCode(typecode, id, name); |
| } |
| |
| /** {@inheritDoc} */ |
| public Any create_any() |
| { |
| gnuAny any = new gnuAny(); |
| any.setOrb(this); |
| return any; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_array_tc(int length, TypeCode element_type) |
| { |
| ArrayTypeCode p = |
| new ArrayTypeCode(TCKind.tk_array, element_type); |
| p.setLength(length); |
| return p; |
| } |
| |
| /** {@inheritDoc} */ |
| public ContextList create_context_list() |
| { |
| return new gnuContextList(); |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_enum_tc(String id, String name, String[] values) |
| { |
| RecordTypeCode r = new RecordTypeCode(TCKind.tk_enum); |
| for (int i = 0; i < values.length; i++) |
| { |
| r.field().name = values [ i ]; |
| } |
| |
| r.setId(id); |
| r.setName(name); |
| |
| return r; |
| } |
| |
| /** {@inheritDoc} */ |
| public Environment create_environment() |
| { |
| return new gnuEnvironment(); |
| } |
| |
| /** {@inheritDoc} */ |
| public ExceptionList create_exception_list() |
| { |
| return new gnuExceptionList(); |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_exception_tc(String id, String name, |
| StructMember[] members |
| ) |
| { |
| RecordTypeCode r = new RecordTypeCode(TCKind.tk_except); |
| r.setId(id); |
| r.setName(name); |
| |
| for (int i = 0; i < members.length; i++) |
| { |
| r.add(members [ i ]); |
| } |
| |
| return r; |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public TypeCode create_interface_tc(String id, String name) |
| { |
| no(); |
| return null; |
| } |
| |
| /** {@inheritDoc} */ |
| public NVList create_list(int count) |
| { |
| return new gnuNVList(count); |
| } |
| |
| /** {@inheritDoc} */ |
| public NamedValue create_named_value(String s, Any any, int flags) |
| { |
| return new gnuNamedValue(); |
| } |
| |
| /** {@inheritDoc} */ |
| public OutputStream create_output_stream() |
| { |
| BufferedCdrOutput stream = new BufferedCdrOutput(); |
| stream.setOrb(this); |
| return stream; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_sequence_tc(int bound, TypeCode element_type) |
| { |
| ArrayTypeCode p = |
| new ArrayTypeCode(TCKind.tk_sequence, element_type); |
| p.setLength(bound); |
| return p; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_string_tc(int bound) |
| { |
| StringTypeCode p = new StringTypeCode(TCKind.tk_string); |
| p.setLength(bound); |
| return p; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_struct_tc(String id, String name, |
| StructMember[] members |
| ) |
| { |
| RecordTypeCode r = new RecordTypeCode(TCKind.tk_struct); |
| r.setId(id); |
| r.setName(name); |
| |
| for (int i = 0; i < members.length; i++) |
| { |
| r.add(members [ i ]); |
| } |
| |
| return r; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_union_tc(String id, String name, |
| TypeCode discriminator_type, UnionMember[] members |
| ) |
| { |
| RecordTypeCode r = new RecordTypeCode(TCKind.tk_union); |
| r.setId(id); |
| r.setName(name); |
| r.setDiscriminator_type(discriminator_type); |
| r.setDefaultIndex(0); |
| |
| for (int i = 0; i < members.length; i++) |
| { |
| r.add(members [ i ]); |
| } |
| |
| return r; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode create_wstring_tc(int bound) |
| { |
| StringTypeCode p = new StringTypeCode(TCKind.tk_wstring); |
| p.setLength(bound); |
| return p; |
| } |
| |
| /** {@inheritDoc} */ |
| public TypeCode get_primitive_tc(TCKind tcKind) |
| { |
| try |
| { |
| return TypeKindNamer.getPrimitveTC(tcKind); |
| } |
| catch (BadKind ex) |
| { |
| throw new BAD_PARAM("This is not a primitive type code: " + |
| tcKind.value() |
| ); |
| } |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public String[] list_initial_services() |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public String object_to_string(org.omg.CORBA.Object forObject) |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws InvalidName never in this class, but it is thrown in the derived |
| * classes. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public org.omg.CORBA.Object resolve_initial_references(String name) |
| throws InvalidName |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * Shutdown the ORB server. |
| * |
| * For RestrictedORB, returns witout action. |
| */ |
| public void run() |
| { |
| } |
| |
| /** |
| * Shutdown the ORB server. |
| * |
| * For RestrictedORB, returns witout action. |
| */ |
| public void shutdown(boolean wait_for_completion) |
| { |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public org.omg.CORBA.Object string_to_object(String IOR) |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| protected void set_parameters(Applet app, Properties props) |
| { |
| no(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| protected void set_parameters(String[] args, Properties props) |
| { |
| no(); |
| } |
| |
| /** |
| * Throws an exception, stating that the given method is not supported by the |
| * Restricted ORB. |
| */ |
| private final void no() |
| { |
| // Apart the programming errors, this can only happen if the |
| // malicious code is trying to do that it is not allowed. |
| throw new NO_IMPLEMENT("Use init(args, props) for the functional version."); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public Request get_next_response() throws org.omg.CORBA.WrongTransaction |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public boolean poll_next_response() |
| { |
| no(); |
| throw new InternalError(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public void send_multiple_requests_deferred(Request[] requests) |
| { |
| no(); |
| } |
| |
| /** |
| * This method is not allowed for a RestrictedORB. |
| * |
| * @throws NO_IMPLEMENT, always. |
| */ |
| public void send_multiple_requests_oneway(Request[] requests) |
| { |
| no(); |
| } |
| |
| /** |
| * Register the value factory under the given repository id. |
| */ |
| public ValueFactory register_value_factory(String repository_id, |
| ValueFactory factory |
| ) |
| { |
| factories.put(repository_id, factory); |
| return factory; |
| } |
| |
| /** |
| * Unregister the value factroy. |
| */ |
| public void unregister_value_factory(String id) |
| { |
| factories.remove(id); |
| } |
| |
| /** |
| * Look for the value factory for the value, having the given repository id. |
| * The implementation checks for the registered value factories first. If none |
| * found, it tries to load and instantiate the class, mathing the given naming |
| * convention. If this faild, null is returned. |
| * |
| * @param repository_id a repository id. |
| * |
| * @return a found value factory, null if none. |
| */ |
| public ValueFactory lookup_value_factory(String repository_id) |
| { |
| ValueFactory f = (ValueFactory) factories.get(repository_id); |
| if (f != null) |
| { |
| return f; |
| } |
| |
| f = (ValueFactory) ObjectCreator.createObject(repository_id, |
| "DefaultFactory" |
| ); |
| if (f != null) |
| { |
| factories.put(repository_id, f); |
| } |
| return f; |
| } |
| |
| /** |
| * Destroy the interceptors, if they are present. |
| */ |
| public void destroy() |
| { |
| if (iIor != null) |
| { |
| iIor.destroy(); |
| iIor = null; |
| } |
| |
| if (iServer != null) |
| { |
| iServer.destroy(); |
| iServer = null; |
| } |
| |
| if (iClient != null) |
| { |
| iClient.destroy(); |
| iClient = null; |
| } |
| |
| super.destroy(); |
| } |
| |
| /** |
| * Create a typecode, representing a tree-like structure. |
| * This structure contains a member that is a sequence of the same type, |
| * as the structure itself. You can imagine as if the folder definition |
| * contains a variable-length array of the enclosed (nested) folder |
| * definitions. In this way, it is possible to have a tree like |
| * structure that can be transferred via CORBA CDR stream. |
| * |
| * @deprecated It is easier and clearler to use a combination of |
| * create_recursive_tc and create_sequence_tc instead. |
| * |
| * @param bound the maximal expected number of the nested components |
| * on each node; 0 if not limited. |
| * |
| * @param offset the position of the field in the returned structure |
| * that contains the sequence of the structures of the same field. |
| * The members before this field are intialised using parameterless |
| * StructMember constructor. |
| * |
| * @return a typecode, defining a stucture, where a member at the |
| * <code>offset</code> position defines an array of the identical |
| * structures. |
| * |
| * @see #create_recursive_tc(String) |
| * @see #create_sequence_tc(int, TypeCode) |
| */ |
| public TypeCode create_recursive_sequence_tc(int bound, int offset) |
| { |
| RecordTypeCode r = new RecordTypeCode(TCKind.tk_struct); |
| for (int i = 0; i < offset; i++) |
| r.add(new StructMember()); |
| |
| TypeCode recurs = new PrimitiveTypeCode(TCKind.tk_sequence); |
| |
| r.add(new StructMember("", recurs, null)); |
| return r; |
| } |
| |
| /** |
| * Get the default context of this ORB. This is an initial root of all |
| * contexts. |
| * |
| * The default method returns a new context with the empty name and |
| * no parent context. |
| * |
| * @return the default context of this ORB. |
| */ |
| public Context get_default_context() |
| { |
| return new gnuContext("", null); |
| } |
| |
| } |