/*

 * Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package org.omg.CORBA;

import org.omg.CORBA.portable.*;

import org.omg.CORBA.ORBPackage.InvalidName;

import java.util.Properties;

import java.applet.Applet;

import java.io.File;

import java.io.FileInputStream;

import java.security.AccessController;

import java.security.PrivilegedAction;

/**

 * A class providing APIs for the CORBA Object Request Broker

 * features.  The {@code ORB} class also provides

 * "pluggable ORB implementation" APIs that allow another vendor's ORB

 * implementation to be used.

 * <P>

 * An ORB makes it possible for CORBA objects to communicate

 * with each other by connecting objects making requests (clients) with

 * objects servicing requests (servers).

 * <P>

 *

 * The {@code ORB} class, which

 * encapsulates generic CORBA functionality, does the following:

 * (Note that items 5 and 6, which include most of the methods in

 * the class {@code ORB}, are typically used with the

 * {@code Dynamic Invocation Interface} (DII) and

 * the {@code Dynamic Skeleton Interface} (DSI).

 * These interfaces may be used by a developer directly, but

 * most commonly they are used by the ORB internally and are

 * not seen by the general programmer.)

 * <OL>

 * <li> initializes the ORB implementation by supplying values for

 *      predefined properties and environmental parameters

 * <li> obtains initial object references to services such as

 * the NameService using the method {@code resolve_initial_references}

 * <li> converts object references to strings and back

 * <li> connects the ORB to a servant (an instance of a CORBA object

 * implementation) and disconnects the ORB from a servant

 * <li> creates objects such as

 *   <ul>

 *   <li>{@code TypeCode}

 *   <li>{@code Any}

 *   <li>{@code NamedValue}

 *   <li>{@code Context}

 *   <li>{@code Environment}

 *   <li>lists (such as {@code NVList}) containing these objects

 *   </ul>

 * <li> sends multiple messages in the DII

 * </OL>

 *

 * <P>

 * The {@code ORB} class can be used to obtain references to objects

 * implemented anywhere on the network.

 * <P>

 * An application or applet gains access to the CORBA environment

 * by initializing itself into an {@code ORB} using one of

 * three {@code init} methods.  Two of the three methods use the properties

 * (associations of a name with a value) shown in the

 * table below.<BR>

 * <TABLE BORDER=1 SUMMARY="Standard Java CORBA Properties">

 * <TR><TH>Property Name</TH>   <TH>Property Value</TH></TR>

 * <CAPTION>Standard Java CORBA Properties:</CAPTION>

 *     <TR><TD>org.omg.CORBA.ORBClass</TD>

 *     <TD>class name of an ORB implementation</TD></TR>

 *     <TR><TD>org.omg.CORBA.ORBSingletonClass</TD>

 *     <TD>class name of the ORB returned by {@code init()}</TD></TR>

 * </TABLE>

 * <P>

 * These properties allow a different vendor's {@code ORB}

 * implementation to be "plugged in."

 * <P>

 * When an ORB instance is being created, the class name of the ORB

 * implementation is located using

 * the following standard search order:

 *

 * <OL>

 *     <LI>check in Applet parameter or application string array, if any

 *

 *     <LI>check in properties parameter, if any

 *

 *

 *     <LI>check in the orb.properties file located in the user.home

 *

 *

 *     <LI>fall back on a hardcoded default behavior (use the Java&nbsp;IDL

 *         implementation)

 * </OL>

 * <P>

 * Note that Java IDL provides a default implementation for the

 * fully-functional ORB and for the Singleton ORB.  When the method

 * {@code init} is given no parameters, the default Singleton

 * ORB is returned.  When the method {@code init} is given parameters

 * but no ORB class is specified, the Java IDL ORB implementation

 * is returned.

 * <P>

 * The following code fragment creates an {@code ORB} object

 * initialized with the default ORB Singleton.

 * This ORB has a

 * restricted implementation to prevent malicious applets from doing

 * anything beyond creating typecodes.

 * It is called a singleton

 * because there is only one instance for an entire virtual machine.

 * <PRE>

 *    ORB orb = ORB.init();

 * </PRE>

 * <P>

 * The following code fragment creates an {@code ORB} object

 * for an application.  The parameter {@code args}

 * represents the arguments supplied to the application's {@code main}

 * method.  Since the property specifies the ORB class to be

 * "SomeORBImplementation", the new ORB will be initialized with

 * that ORB implementation.  If p had been null,

 * and the arguments had not specified an ORB class,

 * the new ORB would have been

 * initialized with the default Java IDL implementation.

 * <PRE>

 *    Properties p = new Properties();

 *    p.put("org.omg.CORBA.ORBClass", "SomeORBImplementation");

 *    ORB orb = ORB.init(args, p);

 * </PRE>

 * <P>

 * The following code fragment creates an {@code ORB} object

 * for the applet supplied as the first parameter.  If the given

 * applet does not specify an ORB class, the new ORB will be

 * initialized with the default Java IDL implementation.

 * <PRE>

 *    ORB orb = ORB.init(myApplet, null);

 * </PRE>

 * <P>

 * An application or applet can be initialized in one or more ORBs.

 * ORB initialization is a bootstrap call into the CORBA world.

 *

 *

 * @implNote

 * When a singleton ORB is configured via the system property,

 * or orb.properties, it will be

 * located, and loaded via the system class loader.

 * Thus, where appropriate, it is necessary that

 * the classes for this alternative ORBSingleton are available on the application's class path.

 * It should be noted that the singleton ORB is system wide.

 * When a per-application ORB is created via the 2-arg init methods,

 * then it will be located using the thread context class loader.

 *

 * @since   JDK1.2

 */

abstract public class ORB {

    //

    // This is the ORB implementation used when nothing else is specified.

    // Whoever provides this class customizes this string to

    // point at their ORB implementation.

    //

    private static final String ORBClassKey = "org.omg.CORBA.ORBClass";

    private static final String ORBSingletonClassKey = "org.omg.CORBA.ORBSingletonClass";

    // check that access to the class is not restricted by the security manager.

    private static void checkPackageAccess(String name) {

        SecurityManager s = System.getSecurityManager();

        if (s != null) {

            String cname = name.replace('/', '.');

            if (cname.startsWith("[")) {

                int b = cname.lastIndexOf('[') + 2;

                if (b > 1 && b < cname.length()) {

                    cname = cname.substring(b);

                }

            }

            int i = cname.lastIndexOf('.');

            if (i != -1) {

                s.checkPackageAccess(cname.substring(0, i));

            }

        }

    }

    //

    // The global instance of the singleton ORB implementation which

    // acts as a factory for typecodes for generated Helper classes.

    // TypeCodes should be immutable since they may be shared across

    // different security contexts (applets). There should be no way to

    // use a TypeCode as a storage depot for illicitly passing

    // information or Java objects between different security contexts.

    //

    static private ORB singleton;

    // Get System property

    private static String getSystemProperty(final String name) {

        // This will not throw a SecurityException because this

        // class was loaded from rt.jar using the bootstrap classloader.

        String propValue = (String) AccessController.doPrivileged(

            new PrivilegedAction() {

                public java.lang.Object run() {

                    return System.getProperty(name);

                }

            }

        );

        return propValue;

    }

    // Get property from orb.properties in either <user.home> or <java-home>/lib

    // directories.

    private static String getPropertyFromFile(final String name) {

        // This will not throw a SecurityException because this

        // class was loaded from rt.jar using the bootstrap classloader.

        String propValue = (String) AccessController.doPrivileged(

            new PrivilegedAction() {

                private Properties getFileProperties( String fileName ) {

                    try {

                        File propFile = new File( fileName ) ;

                        if (!propFile.exists())

                            return null ;

                        Properties props = new Properties() ;

                        FileInputStream fis = new FileInputStream(propFile);

                        try {

                            props.load( fis );

                        } finally {

                            fis.close() ;

                        }

                        return props ;

                    } catch (Exception exc) {

                        return null ;

                    }

                }

                public java.lang.Object run() {

                    String userHome = System.getProperty("user.home");

                    String fileName = userHome + File.separator +

                        "orb.properties" ;

                    Properties props = getFileProperties( fileName ) ;

                    if (props != null) {

                        String value = props.getProperty( name ) ;

                        if (value != null)

                            return value ;

                    }

                    String javaHome = System.getProperty("java.home");

                    if (props == null)

                    else

                }

            }

        );

        return propValue;

    }

    /**

     * Returns the {@code ORB} singleton object. This method always returns the

     * same ORB instance, which is an instance of the class described by the

     * {@code org.omg.CORBA.ORBSingletonClass} system property.

     * <P>

     * This no-argument version of the method {@code init} is used primarily

     * as a factory for {@code TypeCode} objects, which are used by

     * {@code Helper} classes to implement the method {@code type}.

     * It is also used to create {@code Any} objects that are used to

     * describe {@code union} labels (as part of creating a

     * {@code TypeCode} object for a {@code union}).

     * <P>

     * This method is not intended to be used by applets, and in the event

     * that it is called in an applet environment, the ORB it returns

     * is restricted so that it can be used only as a factory for

     * {@code TypeCode} objects.  Any {@code TypeCode} objects

     * it produces can be safely shared among untrusted applets.

     * <P>

     * If an ORB is created using this method from an applet,

     * a system exception will be thrown if

     * methods other than those for

     * creating {@code TypeCode} objects are invoked.

     *

     * @return the singleton ORB

     *

     * @implNote

     * When configured via the system property, or orb.properties,

     * the system-wide singleton ORB is located via the

     * system class loader.

     */

    public static synchronized ORB init() {

        if (singleton == null) {

            String className = getSystemProperty(ORBSingletonClassKey);

            if (className == null)

                className = getPropertyFromFile(ORBSingletonClassKey);

            if ((className == null) ||

                    (className.equals("com.sun.corba.se.impl.orb.ORBSingleton"))) {

                singleton = new com.sun.corba.se.impl.orb.ORBSingleton();

            } else {

                singleton = create_impl_with_systemclassloader(className);

            }

        }

        return singleton;

    }

   private static ORB create_impl_with_systemclassloader(String className) {

        try {

            checkPackageAccess(className);

            ClassLoader cl = ClassLoader.getSystemClassLoader();

            Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;

            Class<?> singletonOrbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass);

            return (ORB)singletonOrbClass.newInstance();

        } catch (Throwable ex) {

            SystemException systemException = new INITIALIZE(

                "can't instantiate default ORB implementation " + className);

            systemException.initCause(ex);

            throw systemException;

        }

    }

    private static ORB create_impl(String className) {

        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        if (cl == null)

            cl = ClassLoader.getSystemClassLoader();

        try {

            checkPackageAccess(className);

            Class<org.omg.CORBA.ORB> orbBaseClass = org.omg.CORBA.ORB.class;

            Class<?> orbClass = Class.forName(className, true, cl).asSubclass(orbBaseClass);

            return (ORB)orbClass.newInstance();

        } catch (Throwable ex) {

            SystemException systemException = new INITIALIZE(

               "can't instantiate default ORB implementation " + className);

            systemException.initCause(ex);

            throw systemException;

        }

    }

    /**

     * Creates a new {@code ORB} instance for a standalone

     * application.  This method may be called from applications

     * only and returns a new fully functional {@code ORB} object

     * each time it is called.

     * @param args command-line arguments for the application's {@code main}

     *             method; may be {@code null}

     * @param props application-specific properties; may be {@code null}

     * @return the newly-created ORB instance

     *

     * @implNote

     * When configured via the system property, or orb.properties,

     * the ORB is located via the thread context class loader.

     */

    public static ORB init(String[] args, Properties props) {

        //

        // Note that there is no standard command-line argument for

        // specifying the default ORB implementation. For an

        // application you can choose an implementation either by

        // setting the CLASSPATH to pick a different org.omg.CORBA

        // and it's baked-in ORB implementation default or by

        // setting an entry in the properties object or in the

        // system properties.

        //

        String className = null;

        ORB orb;

        if (props != null)

            className = props.getProperty(ORBClassKey);

        if (className == null)

            className = getSystemProperty(ORBClassKey);

        if (className == null)

            className = getPropertyFromFile(ORBClassKey);

        if ((className == null) ||

                    (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {

            orb = new com.sun.corba.se.impl.orb.ORBImpl();

        } else {

            orb = create_impl(className);

        }

        orb.set_parameters(args, props);

        return orb;

    }

    /**

     * Creates a new {@code ORB} instance for an applet.  This

     * method may be called from applets only and returns a new

     * fully-functional {@code ORB} object each time it is called.

     * @param app the applet; may be {@code null}

     * @param props applet-specific properties; may be {@code null}

     * @return the newly-created ORB instance

     *

     * @implNote

     * When configured via the system property, or orb.properties,

     * the ORB is located via the thread context class loader.

     */

    public static ORB init(Applet app, Properties props) {

        String className;

        ORB orb;

        className = app.getParameter(ORBClassKey);

        if (className == null && props != null)

            className = props.getProperty(ORBClassKey);

        if (className == null)

            className = getSystemProperty(ORBClassKey);

        if (className == null)

            className = getPropertyFromFile(ORBClassKey);

        if ((className == null) ||

                    (className.equals("com.sun.corba.se.impl.orb.ORBImpl"))) {

            orb = new com.sun.corba.se.impl.orb.ORBImpl();

        } else {

            orb = create_impl(className);

        }

        orb.set_parameters(app, props);

        return orb;

    }

    /**

     * Allows the ORB implementation to be initialized with the given

     * parameters and properties. This method, used in applications only,

     * is implemented by subclass ORB implementations and called

     * by the appropriate {@code init} method to pass in its parameters.

     *

     * @param args command-line arguments for the application's {@code main}

     *             method; may be {@code null}

     * @param props application-specific properties; may be {@code null}

     */

    abstract protected void set_parameters(String[] args, Properties props);

    /**

     * Allows the ORB implementation to be initialized with the given

     * applet and parameters. This method, used in applets only,

     * is implemented by subclass ORB implementations and called

     * by the appropriate {@code init} method to pass in its parameters.

     *

     * @param app the applet; may be {@code null}

     * @param props applet-specific properties; may be {@code null}

     */

    abstract protected void set_parameters(Applet app, Properties props);

    /**

     * Connects the given servant object (a Java object that is

     * an instance of the server implementation class)

     * to the ORB. The servant class must

     * extend the {@code ImplBase} class corresponding to the interface that is

     * supported by the server. The servant must thus be a CORBA object

     * reference, and inherit from {@code org.omg.CORBA.Object}.

     * Servants created by the user can start receiving remote invocations

     * after the method {@code connect} has been called. A servant may also be

     * automatically and implicitly connected to the ORB if it is passed as

     * an IDL parameter in an IDL method invocation on a non-local object,

     * that is, if the servant object has to be marshalled and sent outside of the

     * process address space.

     * <P>

     * Calling the method {@code connect} has no effect

     * when the servant object is already connected to the ORB.

     * <P>

     * Deprecated by the OMG in favor of the Portable Object Adapter APIs.

     *

     * @param obj The servant object reference

     */

    public void connect(org.omg.CORBA.Object obj) {

        throw new NO_IMPLEMENT();

    }