/*

 * Copyright (c) 2002, 2012, 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 com.sun.corba.se.impl.orb ;

import java.net.URL ;

import java.net.InetSocketAddress;

import java.net.Socket ;

import java.net.ServerSocket ;

import java.io.IOException ;

import java.util.HashMap ;

import java.util.List;

import java.util.Map ;

import java.security.AccessController ;

import java.security.PrivilegedExceptionAction ;

import java.security.PrivilegedActionException ;

import org.omg.PortableInterceptor.ORBInitializer ;

import org.omg.PortableInterceptor.ORBInitInfo ;

import com.sun.corba.se.pept.broker.Broker;

import com.sun.corba.se.pept.encoding.InputObject;

import com.sun.corba.se.pept.encoding.OutputObject;

import com.sun.corba.se.pept.protocol.MessageMediator;

import com.sun.corba.se.pept.transport.Acceptor;

import com.sun.corba.se.pept.transport.Connection;

import com.sun.corba.se.pept.transport.ContactInfo;

import com.sun.corba.se.pept.transport.ContactInfoList;

import com.sun.corba.se.pept.transport.EventHandler;

import com.sun.corba.se.pept.transport.InboundConnectionCache;

import com.sun.corba.se.spi.ior.IOR ;

import com.sun.corba.se.spi.ior.ObjectKey ;

import com.sun.corba.se.spi.ior.iiop.GIOPVersion ;

import com.sun.corba.se.spi.logging.CORBALogDomains ;

import com.sun.corba.se.spi.orb.ORB;

import com.sun.corba.se.spi.orb.Operation ;

import com.sun.corba.se.spi.orb.OperationFactory ;

import com.sun.corba.se.spi.orb.ParserData ;

import com.sun.corba.se.spi.orb.ParserDataFactory ;

import com.sun.corba.se.spi.orb.StringPair ;

import com.sun.corba.se.spi.transport.CorbaContactInfoList;

import com.sun.corba.se.spi.transport.CorbaContactInfoListFactory;

import com.sun.corba.se.spi.transport.CorbaTransportManager;

import com.sun.corba.se.spi.transport.IORToSocketInfo;

import com.sun.corba.se.spi.transport.ReadTimeouts;

import com.sun.corba.se.spi.transport.SocketInfo;

import com.sun.corba.se.spi.transport.IIOPPrimaryToContactInfo;

import com.sun.corba.se.spi.transport.TransportDefault;

import com.sun.corba.se.impl.encoding.CodeSetComponentInfo ;

import com.sun.corba.se.impl.encoding.OSFCodeSetRegistry ;

import com.sun.corba.se.impl.legacy.connection.USLPort ;

import com.sun.corba.se.impl.logging.ORBUtilSystemException ;

import com.sun.corba.se.impl.oa.poa.BadServerIdHandler ;

import com.sun.corba.se.impl.orbutil.ORBClassLoader ;

import com.sun.corba.se.impl.orbutil.ORBConstants ;

import com.sun.corba.se.impl.protocol.giopmsgheaders.KeyAddr ;

import com.sun.corba.se.impl.protocol.giopmsgheaders.ProfileAddr ;

import com.sun.corba.se.impl.protocol.giopmsgheaders.ReferenceAddr ;

import com.sun.corba.se.impl.transport.DefaultIORToSocketInfoImpl;

import com.sun.corba.se.impl.transport.DefaultSocketFactoryImpl;

/** Initialize the parser data for the standard ORB parser.  This is used both

 * to implement ORBDataParserImpl and to provide the basic testing framework

 * for ORBDataParserImpl.

 */

public class ParserTable {

    private static String MY_CLASS_NAME = ParserTable.class.getName() ;

    private static ParserTable myInstance = new ParserTable() ;

    private ORBUtilSystemException wrapper ;

    public static ParserTable get()

    {

        return myInstance ;

    }

    private ParserData[] parserData ;

    public ParserData[] getParserData()

    {

        ParserData[] parserArray = new ParserData[parserData.length];

        System.arraycopy(parserData, 0, parserArray, 0, parserData.length);

        return parserArray;

    }

    private ParserTable() {

        wrapper = ORBUtilSystemException.get( CORBALogDomains.ORB_LIFECYCLE ) ;

        String codeSetTestString =

            OSFCodeSetRegistry.ISO_8859_1_VALUE + "," +

            OSFCodeSetRegistry.UTF_16_VALUE + "," +

            OSFCodeSetRegistry.ISO_646_VALUE ;

        String[] debugTestData = { "subcontract", "poa", "transport" } ;

        USLPort[] USLPorts = { new USLPort( "FOO", 2701 ), new USLPort( "BAR", 3333 ) } ;

        ReadTimeouts readTimeouts =

               TransportDefault.makeReadTimeoutsFactory().create(

                    ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR);

        ORBInitializer[] TestORBInitializers =

            { null,

              new TestORBInitializer1(),

              new TestORBInitializer2() }  ;

        StringPair[] TestORBInitData = {

            new StringPair( "foo.bar.blech.NonExistent", "dummy" ),

            new StringPair( MY_CLASS_NAME + "$TestORBInitializer1", "dummy" ),

            new StringPair( MY_CLASS_NAME + "$TestORBInitializer2", "dummy" ) } ;

        Acceptor[] TestAcceptors =

            { new TestAcceptor2(),

              new TestAcceptor1(),

              null }  ;

        // REVISIT: The test data gets put into a Properties object where

        // order is not guaranteed.  Thus the above array is in reverse.

        StringPair[] TestAcceptorData = {

            new StringPair( "foo.bar.blech.NonExistent", "dummy" ),

            new StringPair( MY_CLASS_NAME + "$TestAcceptor1", "dummy" ),

            new StringPair( MY_CLASS_NAME + "$TestAcceptor2", "dummy" ) } ;

        StringPair[] TestORBInitRefData =

            { new StringPair( "Foo", "ior:930492049394" ),

              new StringPair( "Bar", "ior:3453465785633576" ) } ;

        URL testServicesURL = null ;

        String testServicesString = "corbaloc::camelot/NameService" ;

        try {

            testServicesURL = new URL( testServicesString )  ;

        } catch (Exception exc) {

        }

        // propertyName,

        // operation,

        // fieldName, defaultValue,

        // testValue, testData (string or Pair[])

        ParserData[] pd = {

            ParserDataFactory.make( ORBConstants.DEBUG_PROPERTY,

                OperationFactory.listAction( ",", OperationFactory.stringAction()),

                "debugFlags", new String[0],

                debugTestData, "subcontract,poa,transport" ),

            ParserDataFactory.make( ORBConstants.INITIAL_HOST_PROPERTY,

                OperationFactory.stringAction(),

                "ORBInitialHost", "",

                "Foo", "Foo" ),

            ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,

                OperationFactory.integerAction(),

                "ORBInitialPort", new Integer( ORBConstants.DEFAULT_INITIAL_PORT ),

                new Integer( 27314 ), "27314" ),

            // Where did this come from?

            //ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,

                //OperationFactory.booleanAction(),

                //"ORBInitialPortInitialized", Boolean.FALSE,

                //Boolean.TRUE, "27314" ),

            ParserDataFactory.make( ORBConstants.SERVER_HOST_PROPERTY,

                OperationFactory.stringAction(),

                "ORBServerHost", "",

                "camelot", "camelot" ),

            ParserDataFactory.make( ORBConstants.SERVER_PORT_PROPERTY,

                OperationFactory.integerAction(),

                "ORBServerPort", new Integer( 0 ),

                new Integer( 38143 ), "38143" ),

            // NOTE: We are putting SERVER_HOST_NAME configuration info into

            // DataCollectorBase to avoid a security hole.  However, that forces

            // us to also set LISTEN_ON_ALL_INTERFACES at the same time.

            // This all needs to be cleaned up for two reasons: to get configuration

            // out of DataCollectorBase and to correctly support multihoming.

            ParserDataFactory.make( ORBConstants.LISTEN_ON_ALL_INTERFACES,

                OperationFactory.stringAction(),

                "listenOnAllInterfaces", ORBConstants.LISTEN_ON_ALL_INTERFACES,

                "foo", "foo" ),

            ParserDataFactory.make( ORBConstants.ORB_ID_PROPERTY,

                OperationFactory.stringAction(),

                "orbId", "",

                "foo", "foo" ),

            ParserDataFactory.make( ORBConstants.OLD_ORB_ID_PROPERTY,

                OperationFactory.stringAction(),

                "orbId", "",

                "foo", "foo" ),

            ParserDataFactory.make( ORBConstants.ORB_SERVER_ID_PROPERTY,

                OperationFactory.integerAction(),

                "persistentServerId", new Integer(-1),

                new Integer( 1234), "1234" ),

            ParserDataFactory.make(

                ORBConstants.ORB_SERVER_ID_PROPERTY,

                OperationFactory.setFlagAction(),

                "persistentServerIdInitialized", Boolean.FALSE,

                Boolean.TRUE, "1234" ),

            ParserDataFactory.make(

                ORBConstants.ORB_SERVER_ID_PROPERTY,

                OperationFactory.setFlagAction(),

                "orbServerIdPropertySpecified", Boolean.FALSE,

                Boolean.TRUE, "1234" ),

            // REVISIT after switch

            // ParserDataFactory.make( ORBConstants.INITIAL_SERVICES_PROPERTY,

                // OperationFactory.URLAction(),

                // "servicesURL", null,

                // testServicesURL, testServicesString ),

            // ParserDataFactory.make( ORBConstants.DEFAULT_INIT_REF_PROPERTY,

                // OperationFactory.stringAction(),

                // "defaultInitRef", null,

                // "Fooref", "Fooref" ),

            ParserDataFactory.make( ORBConstants.HIGH_WATER_MARK_PROPERTY,

                OperationFactory.integerAction(),

                "highWaterMark", new Integer( 240 ),

                new Integer( 3745 ), "3745" ),

            ParserDataFactory.make( ORBConstants.LOW_WATER_MARK_PROPERTY,

                OperationFactory.integerAction(),

                "lowWaterMark", new Integer( 100 ),

                new Integer( 12 ), "12" ),

            ParserDataFactory.make( ORBConstants.NUMBER_TO_RECLAIM_PROPERTY,

                OperationFactory.integerAction(),

                "numberToReclaim", new Integer( 5 ),

                new Integer( 231 ), "231" ),

            ParserDataFactory.make( ORBConstants.GIOP_VERSION,

                makeGVOperation(),

                "giopVersion", GIOPVersion.DEFAULT_VERSION,

                new GIOPVersion( 2, 3 ), "2.3" ),

            ParserDataFactory.make( ORBConstants.GIOP_FRAGMENT_SIZE,

                makeFSOperation(), "giopFragmentSize",

                new Integer( ORBConstants.GIOP_DEFAULT_FRAGMENT_SIZE ),

                new Integer( 65536 ), "65536" ),

            ParserDataFactory.make( ORBConstants.GIOP_BUFFER_SIZE,

                OperationFactory.integerAction(),

                "giopBufferSize", new Integer( ORBConstants.GIOP_DEFAULT_BUFFER_SIZE ),

                new Integer( 234000 ), "234000" ),

            ParserDataFactory.make( ORBConstants.GIOP_11_BUFFMGR,

                makeBMGROperation(),

                "giop11BuffMgr", new Integer( ORBConstants.DEFAULT_GIOP_11_BUFFMGR ),

                new Integer( 1 ), "CLCT" ),

            ParserDataFactory.make( ORBConstants.GIOP_12_BUFFMGR,

                makeBMGROperation(),

                "giop12BuffMgr", new Integer( ORBConstants.DEFAULT_GIOP_12_BUFFMGR ),

                new Integer( 0 ), "GROW" ),

            // Note that the same property is used to set two different

            // fields here.  This requires that both entries use the same test

            // data, or the test will fail.

            ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,

                OperationFactory.compose( OperationFactory.integerRangeAction( 0, 3 ),

                    OperationFactory.convertIntegerToShort() ),

                "giopTargetAddressPreference",

                new Short( ORBConstants.ADDR_DISP_HANDLE_ALL ),

                new Short( (short)2 ), "2" ),

            ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,

                makeADOperation(),

                "giopAddressDisposition", new Short( KeyAddr.value ),

                new Short( (short)2 ), "2" ),

            ParserDataFactory.make( ORBConstants.ALWAYS_SEND_CODESET_CTX_PROPERTY,

                OperationFactory.booleanAction(),

                "alwaysSendCodeSetCtx", Boolean.TRUE,

                Boolean.FALSE, "false"),

            ParserDataFactory.make( ORBConstants.USE_BOMS,

                OperationFactory.booleanAction(),

                "useByteOrderMarkers",

                    Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS ),

                Boolean.FALSE, "false" ),

            ParserDataFactory.make( ORBConstants.USE_BOMS_IN_ENCAPS,

                OperationFactory.booleanAction(),

                "useByteOrderMarkersInEncaps",

                    Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS_IN_ENCAPS ),

                Boolean.FALSE, "false" ),

            ParserDataFactory.make( ORBConstants.CHAR_CODESETS,

                makeCSOperation(),

                "charData", CodeSetComponentInfo.JAVASOFT_DEFAULT_CODESETS.getCharComponent(),

                CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),

            ParserDataFactory.make( ORBConstants.WCHAR_CODESETS,

                makeCSOperation(),

                "wcharData", CodeSetComponentInfo.JAVASOFT_DEFAULT_CODESETS.getWCharComponent(),

                CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),

            ParserDataFactory.make( ORBConstants.ALLOW_LOCAL_OPTIMIZATION,

                OperationFactory.booleanAction(),

                "allowLocalOptimization", Boolean.FALSE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.LEGACY_SOCKET_FACTORY_CLASS_PROPERTY,

                makeLegacySocketFactoryOperation(),

                // No default - must be set by user if they are using

                // legacy socket factory.

                "legacySocketFactory", null,

                new TestLegacyORBSocketFactory(),

                MY_CLASS_NAME + "$TestLegacyORBSocketFactory" ),

            ParserDataFactory.make( ORBConstants.SOCKET_FACTORY_CLASS_PROPERTY,

                makeSocketFactoryOperation(),

                "socketFactory", new DefaultSocketFactoryImpl(),

                new TestORBSocketFactory(),

                MY_CLASS_NAME + "$TestORBSocketFactory" ),

            ParserDataFactory.make( ORBConstants.LISTEN_SOCKET_PROPERTY,

                makeUSLOperation() ,

                "userSpecifiedListenPorts", new USLPort[0],

                USLPorts, "FOO:2701,BAR:3333" ),

            ParserDataFactory.make( ORBConstants.IOR_TO_SOCKET_INFO_CLASS_PROPERTY,

                makeIORToSocketInfoOperation(),

                "iorToSocketInfo", new DefaultIORToSocketInfoImpl(),

                new TestIORToSocketInfo(),

                MY_CLASS_NAME + "$TestIORToSocketInfo" ),

            ParserDataFactory.make( ORBConstants.IIOP_PRIMARY_TO_CONTACT_INFO_CLASS_PROPERTY,

                makeIIOPPrimaryToContactInfoOperation(),

                "iiopPrimaryToContactInfo", null,

                new TestIIOPPrimaryToContactInfo(),

                MY_CLASS_NAME + "$TestIIOPPrimaryToContactInfo" ),

            ParserDataFactory.make( ORBConstants.CONTACT_INFO_LIST_FACTORY_CLASS_PROPERTY,

                makeContactInfoListFactoryOperation(),

                "corbaContactInfoListFactory", null,

                new TestContactInfoListFactory(),

                MY_CLASS_NAME + "$TestContactInfoListFactory" ),

            ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,

                OperationFactory.integerAction(),

                "persistentServerPort", new Integer( 0 ),

                new Integer( 2743 ), "2743" ),

            ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,

                OperationFactory.setFlagAction(),

                "persistentPortInitialized", Boolean.FALSE,

                Boolean.TRUE, "2743" ),

            ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

                OperationFactory.integerAction(),

                "persistentServerId", new Integer( 0 ),

                new Integer( 294 ), "294" ),

            ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

                OperationFactory.setFlagAction(),

                "persistentServerIdInitialized", Boolean.FALSE,

                Boolean.TRUE, "294" ),

            ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

                OperationFactory.setFlagAction(),

                "orbServerIdPropertySpecified", Boolean.FALSE,

                Boolean.TRUE, "294" ),

            ParserDataFactory.make( ORBConstants.ACTIVATED_PROPERTY,

                OperationFactory.booleanAction(),

                "serverIsORBActivated", Boolean.FALSE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.BAD_SERVER_ID_HANDLER_CLASS_PROPERTY,

                OperationFactory.classAction(),

                "badServerIdHandlerClass", null,

                TestBadServerIdHandler.class, MY_CLASS_NAME + "$TestBadServerIdHandler" ),

            ParserDataFactory.make( ORBConstants.PI_ORB_INITIALIZER_CLASS_PREFIX,

                makeROIOperation(),

                "orbInitializers", new ORBInitializer[0],

                TestORBInitializers, TestORBInitData, ORBInitializer.class ),

            ParserDataFactory.make( ORBConstants.ACCEPTOR_CLASS_PREFIX_PROPERTY,

                makeAcceptorInstantiationOperation(),

                "acceptors", new Acceptor[0],

                TestAcceptors, TestAcceptorData, Acceptor.class ),

            //

            // Socket/Channel control

            //

            // Acceptor:

            // useNIOSelector == true

            //   useSelectThreadToWait = true

            //   useWorkerThreadForEvent = false

            // else

            //   useSelectThreadToWait = false

            //   useWorkerThreadForEvent = true

            // Connection:

            // useNIOSelector == true

            //   useSelectThreadToWait = true

            //   useWorkerThreadForEvent = true

            // else

            //   useSelectThreadToWait = false

            //   useWorkerThreadForEvent = true

            ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_TYPE_PROPERTY,

                OperationFactory.stringAction(),

                "acceptorSocketType", ORBConstants.SOCKETCHANNEL,

                "foo", "foo" ),

            ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,

                OperationFactory.booleanAction(),

                "acceptorSocketUseSelectThreadToWait", Boolean.TRUE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,

                OperationFactory.booleanAction(),

                "acceptorSocketUseWorkerThreadForEvent", Boolean.TRUE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_TYPE_PROPERTY,

                OperationFactory.stringAction(),

                "connectionSocketType", ORBConstants.SOCKETCHANNEL,

                "foo", "foo" ),

            ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,

                OperationFactory.booleanAction(),

                "connectionSocketUseSelectThreadToWait", Boolean.TRUE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,

                OperationFactory.booleanAction(),

                "connectionSocketUseWorkerThreadForEvent", Boolean.TRUE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make( ORBConstants.DISABLE_DIRECT_BYTE_BUFFER_USE_PROPERTY,

                OperationFactory.booleanAction(),

                "disableDirectByteBufferUse", Boolean.FALSE,

                Boolean.TRUE, "true" ),

            ParserDataFactory.make(ORBConstants.TRANSPORT_TCP_READ_TIMEOUTS_PROPERTY,

                makeTTCPRTOperation(),

                "readTimeouts",  TransportDefault.makeReadTimeoutsFactory().create(

                    ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,

                    ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR),

                readTimeouts, "100:3000:300:20" ),

            ParserDataFactory.make(

                ORBConstants.ENABLE_JAVA_SERIALIZATION_PROPERTY,

                OperationFactory.booleanAction(),

                "enableJavaSerialization", Boolean.FALSE,

                Boolean.FALSE, "false"),

            ParserDataFactory.make(

                ORBConstants.USE_REP_ID,

                OperationFactory.booleanAction(),

                "useRepId", Boolean.TRUE,

                Boolean.TRUE, "true"),

            ParserDataFactory.make( ORBConstants.ORB_INIT_REF_PROPERTY,

                OperationFactory.identityAction(),

                "orbInitialReferences", new StringPair[0],

                TestORBInitRefData, TestORBInitRefData, StringPair.class )

        } ;

        parserData = pd ;

    }

    public final class TestBadServerIdHandler implements BadServerIdHandler

    {

        public boolean equals( Object other )

        {

            return other instanceof TestBadServerIdHandler ;

        }

        public void handle( ObjectKey objectKey )

        {

        }

    }

    private Operation makeTTCPRTOperation()

    {

        Operation[] fourIop = { OperationFactory.integerAction(),

                                OperationFactory.integerAction(),

                                OperationFactory.integerAction(),

                                OperationFactory.integerAction() } ;

        Operation op2 = OperationFactory.sequenceAction( ":", fourIop ) ;

        Operation rtOp = new Operation() {

            public Object operate(Object value)

            {

                Object[] values = (Object[])value ;

                Integer initialTime = (Integer)(values[0]) ;

                Integer maxGIOPHdrTime = (Integer)(values[1]) ;

                Integer maxGIOPBodyTime = (Integer)(values[2]) ;

                Integer backoffPercent = (Integer)(values[3]) ;

                return TransportDefault.makeReadTimeoutsFactory().create(

                                                   initialTime.intValue(),

                                                   maxGIOPHdrTime.intValue(),

                                                   maxGIOPBodyTime.intValue(),

                                                   backoffPercent.intValue());

            }

        } ;

        Operation ttcprtOp = OperationFactory.compose(op2, rtOp);

        return ttcprtOp;

    }

    private Operation makeUSLOperation()

    {

        Operation[] siop = { OperationFactory.stringAction(),

            OperationFactory.integerAction() } ;

        Operation op2 = OperationFactory.sequenceAction( ":", siop ) ;

        Operation uslop = new Operation() {

            public Object operate( Object value )

            {

                Object[] values = (Object[])value ;

                String type = (String)(values[0]) ;

                Integer port = (Integer)(values[1]) ;

                return new USLPort( type, port.intValue() ) ;

            }

        } ;

        Operation op3 = OperationFactory.compose( op2, uslop ) ;

        Operation listenop = OperationFactory.listAction( ",", op3 ) ;

        return listenop ;

    }

    public static final class TestLegacyORBSocketFactory

        implements com.sun.corba.se.spi.legacy.connection.ORBSocketFactory

    {

        public boolean equals( Object other )

        {

            return other instanceof TestLegacyORBSocketFactory ;

        }