jdk8-mips64-public/corba: src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java@bfd167e38830

     1 /*

     2  * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.  Oracle designates this

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

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

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

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

    15  * accompanied this code).

    16  *

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

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

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

    20  *

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

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

    23  * questions.

    24  */

    26 package com.sun.corba.se.impl.orb ;

    28 import java.net.URL ;

    29 import java.net.InetSocketAddress;

    30 import java.net.Socket ;

    31 import java.net.ServerSocket ;

    33 import java.io.IOException ;

    35 import java.util.HashMap ;

    36 import java.util.List;

    37 import java.util.Map ;

    39 import java.security.AccessController ;

    40 import java.security.PrivilegedExceptionAction ;

    41 import java.security.PrivilegedActionException ;

    43 import org.omg.PortableInterceptor.ORBInitializer ;

    44 import org.omg.PortableInterceptor.ORBInitInfo ;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    88 import sun.corba.SharedSecrets;

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

    91  * to implement ORBDataParserImpl and to provide the basic testing framework

    92  * for ORBDataParserImpl.

    93  */

    94 public class ParserTable {

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

    97     private static ParserTable myInstance = new ParserTable() ;

    99     private ORBUtilSystemException wrapper ;

   101     public static ParserTable get()

   102     {

   103         return myInstance ;

   104     }

   106     private ParserData[] parserData ;

   108     public ParserData[] getParserData()

   109     {

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

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

   112         return parserArray;

   113     }

   115     private ParserTable() {

   116         wrapper = ORBUtilSystemException.get( CORBALogDomains.ORB_LIFECYCLE ) ;

   118         String codeSetTestString =

   119             OSFCodeSetRegistry.ISO_8859_1_VALUE + "," +

   120             OSFCodeSetRegistry.UTF_16_VALUE + "," +

   121             OSFCodeSetRegistry.ISO_646_VALUE ;

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

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

   127         ReadTimeouts readTimeouts =

   128                TransportDefault.makeReadTimeoutsFactory().create(

   129                     ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,

   130                     ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,

   131                     ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,

   132                     ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR);

   134         ORBInitializer[] TestORBInitializers =

   135             { null,

   136               new TestORBInitializer1(),

   137               new TestORBInitializer2() }  ;

   138         StringPair[] TestORBInitData = {

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

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

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

   143         Acceptor[] TestAcceptors =

   144             { new TestAcceptor2(),

   145               new TestAcceptor1(),

   146               null }  ;

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

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

   149         StringPair[] TestAcceptorData = {

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

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

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

   154         StringPair[] TestORBInitRefData =

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

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

   158         URL testServicesURL = null ;

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

   161         try {

   162             testServicesURL = new URL( testServicesString )  ;

   163         } catch (Exception exc) {

   164         }

   166         // propertyName,

   167         // operation,

   168         // fieldName, defaultValue,

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

   170         ParserData[] pd = {

   171             ParserDataFactory.make( ORBConstants.DEBUG_PROPERTY,

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

   173                 "debugFlags", new String[0],

   174                 debugTestData, "subcontract,poa,transport" ),

   175             ParserDataFactory.make( ORBConstants.INITIAL_HOST_PROPERTY,

   176                 OperationFactory.stringAction(),

   177                 "ORBInitialHost", "",

   178                 "Foo", "Foo" ),

   179             ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,

   180                 OperationFactory.integerAction(),

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

   182                 new Integer( 27314 ), "27314" ),

   183             // Where did this come from?

   184             //ParserDataFactory.make( ORBConstants.INITIAL_PORT_PROPERTY,

   185                 //OperationFactory.booleanAction(),

   186                 //"ORBInitialPortInitialized", Boolean.FALSE,

   187                 //Boolean.TRUE, "27314" ),

   188             ParserDataFactory.make( ORBConstants.SERVER_HOST_PROPERTY,

   189                 OperationFactory.stringAction(),

   190                 "ORBServerHost", "",

   191                 "camelot", "camelot" ),

   192             ParserDataFactory.make( ORBConstants.SERVER_PORT_PROPERTY,

   193                 OperationFactory.integerAction(),

   194                 "ORBServerPort", new Integer( 0 ),

   195                 new Integer( 38143 ), "38143" ),

   196             // NOTE: We are putting SERVER_HOST_NAME configuration info into

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

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

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

   200             // out of DataCollectorBase and to correctly support multihoming.

   201             ParserDataFactory.make( ORBConstants.LISTEN_ON_ALL_INTERFACES,

   202                 OperationFactory.stringAction(),

   203                 "listenOnAllInterfaces", ORBConstants.LISTEN_ON_ALL_INTERFACES,

   204                 "foo", "foo" ),

   205             ParserDataFactory.make( ORBConstants.ORB_ID_PROPERTY,

   206                 OperationFactory.stringAction(),

   207                 "orbId", "",

   208                 "foo", "foo" ),

   209             ParserDataFactory.make( ORBConstants.OLD_ORB_ID_PROPERTY,

   210                 OperationFactory.stringAction(),

   211                 "orbId", "",

   212                 "foo", "foo" ),

   213             ParserDataFactory.make( ORBConstants.ORB_SERVER_ID_PROPERTY,

   214                 OperationFactory.integerAction(),

   215                 "persistentServerId", new Integer(-1),

   216                 new Integer( 1234), "1234" ),

   217             ParserDataFactory.make(

   218                 ORBConstants.ORB_SERVER_ID_PROPERTY,

   219                 OperationFactory.setFlagAction(),

   220                 "persistentServerIdInitialized", Boolean.FALSE,

   221                 Boolean.TRUE, "1234" ),

   222             ParserDataFactory.make(

   223                 ORBConstants.ORB_SERVER_ID_PROPERTY,

   224                 OperationFactory.setFlagAction(),

   225                 "orbServerIdPropertySpecified", Boolean.FALSE,

   226                 Boolean.TRUE, "1234" ),

   227             // REVISIT after switch

   228             // ParserDataFactory.make( ORBConstants.INITIAL_SERVICES_PROPERTY,

   229                 // OperationFactory.URLAction(),

   230                 // "servicesURL", null,

   231                 // testServicesURL, testServicesString ),

   232             // ParserDataFactory.make( ORBConstants.DEFAULT_INIT_REF_PROPERTY,

   233                 // OperationFactory.stringAction(),

   234                 // "defaultInitRef", null,

   235                 // "Fooref", "Fooref" ),

   236             ParserDataFactory.make( ORBConstants.HIGH_WATER_MARK_PROPERTY,

   237                 OperationFactory.integerAction(),

   238                 "highWaterMark", new Integer( 240 ),

   239                 new Integer( 3745 ), "3745" ),

   240             ParserDataFactory.make( ORBConstants.LOW_WATER_MARK_PROPERTY,

   241                 OperationFactory.integerAction(),

   242                 "lowWaterMark", new Integer( 100 ),

   243                 new Integer( 12 ), "12" ),

   244             ParserDataFactory.make( ORBConstants.NUMBER_TO_RECLAIM_PROPERTY,

   245                 OperationFactory.integerAction(),

   246                 "numberToReclaim", new Integer( 5 ),

   247                 new Integer( 231 ), "231" ),

   248             ParserDataFactory.make( ORBConstants.GIOP_VERSION,

   249                 makeGVOperation(),

   250                 "giopVersion", GIOPVersion.DEFAULT_VERSION,

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

   252             ParserDataFactory.make( ORBConstants.GIOP_FRAGMENT_SIZE,

   253                 makeFSOperation(), "giopFragmentSize",

   254                 new Integer( ORBConstants.GIOP_DEFAULT_FRAGMENT_SIZE ),

   255                 new Integer( 65536 ), "65536" ),

   256             ParserDataFactory.make( ORBConstants.GIOP_BUFFER_SIZE,

   257                 OperationFactory.integerAction(),

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

   259                 new Integer( 234000 ), "234000" ),

   260             ParserDataFactory.make( ORBConstants.GIOP_11_BUFFMGR,

   261                 makeBMGROperation(),

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

   263                 new Integer( 1 ), "CLCT" ),

   264             ParserDataFactory.make( ORBConstants.GIOP_12_BUFFMGR,

   265                 makeBMGROperation(),

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

   267                 new Integer( 0 ), "GROW" ),

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

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

   271             // data, or the test will fail.

   272             ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,

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

   274                     OperationFactory.convertIntegerToShort() ),

   275                 "giopTargetAddressPreference",

   276                 new Short( ORBConstants.ADDR_DISP_HANDLE_ALL ),

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

   278             ParserDataFactory.make( ORBConstants.GIOP_TARGET_ADDRESSING,

   279                 makeADOperation(),

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

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

   282             ParserDataFactory.make( ORBConstants.ALWAYS_SEND_CODESET_CTX_PROPERTY,

   283                 OperationFactory.booleanAction(),

   284                 "alwaysSendCodeSetCtx", Boolean.TRUE,

   285                 Boolean.FALSE, "false"),

   286             ParserDataFactory.make( ORBConstants.USE_BOMS,

   287                 OperationFactory.booleanAction(),

   288                 "useByteOrderMarkers",

   289                     Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS ),

   290                 Boolean.FALSE, "false" ),

   291             ParserDataFactory.make( ORBConstants.USE_BOMS_IN_ENCAPS,

   292                 OperationFactory.booleanAction(),

   293                 "useByteOrderMarkersInEncaps",

   294                     Boolean.valueOf( ORBConstants.DEFAULT_USE_BYTE_ORDER_MARKERS_IN_ENCAPS ),

   295                 Boolean.FALSE, "false" ),

   296             ParserDataFactory.make( ORBConstants.CHAR_CODESETS,

   297                 makeCSOperation(),

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

   299                 CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),

   300             ParserDataFactory.make( ORBConstants.WCHAR_CODESETS,

   301                 makeCSOperation(),

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

   303                 CodeSetComponentInfo.createFromString( codeSetTestString ), codeSetTestString ),

   304             ParserDataFactory.make( ORBConstants.ALLOW_LOCAL_OPTIMIZATION,

   305                 OperationFactory.booleanAction(),

   306                 "allowLocalOptimization", Boolean.FALSE,

   307                 Boolean.TRUE, "true" ),

   308             ParserDataFactory.make( ORBConstants.LEGACY_SOCKET_FACTORY_CLASS_PROPERTY,

   309                 makeLegacySocketFactoryOperation(),

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

   311                 // legacy socket factory.

   312                 "legacySocketFactory", null,

   313                 new TestLegacyORBSocketFactory(),

   314                 MY_CLASS_NAME + "$TestLegacyORBSocketFactory" ),

   315             ParserDataFactory.make( ORBConstants.SOCKET_FACTORY_CLASS_PROPERTY,

   316                 makeSocketFactoryOperation(),

   317                 "socketFactory", new DefaultSocketFactoryImpl(),

   318                 new TestORBSocketFactory(),

   319                 MY_CLASS_NAME + "$TestORBSocketFactory" ),

   320             ParserDataFactory.make( ORBConstants.LISTEN_SOCKET_PROPERTY,

   321                 makeUSLOperation() ,

   322                 "userSpecifiedListenPorts", new USLPort[0],

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

   324             ParserDataFactory.make( ORBConstants.IOR_TO_SOCKET_INFO_CLASS_PROPERTY,

   325                 makeIORToSocketInfoOperation(),

   326                 "iorToSocketInfo", new DefaultIORToSocketInfoImpl(),

   327                 new TestIORToSocketInfo(),

   328                 MY_CLASS_NAME + "$TestIORToSocketInfo" ),

   329             ParserDataFactory.make( ORBConstants.IIOP_PRIMARY_TO_CONTACT_INFO_CLASS_PROPERTY,

   330                 makeIIOPPrimaryToContactInfoOperation(),

   331                 "iiopPrimaryToContactInfo", null,

   332                 new TestIIOPPrimaryToContactInfo(),

   333                 MY_CLASS_NAME + "$TestIIOPPrimaryToContactInfo" ),

   334             ParserDataFactory.make( ORBConstants.CONTACT_INFO_LIST_FACTORY_CLASS_PROPERTY,

   335                 makeContactInfoListFactoryOperation(),

   336                 "corbaContactInfoListFactory", null,

   337                 new TestContactInfoListFactory(),

   338                 MY_CLASS_NAME + "$TestContactInfoListFactory" ),

   339             ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,

   340                 OperationFactory.integerAction(),

   341                 "persistentServerPort", new Integer( 0 ),

   342                 new Integer( 2743 ), "2743" ),

   343             ParserDataFactory.make( ORBConstants.PERSISTENT_SERVER_PORT_PROPERTY,

   344                 OperationFactory.setFlagAction(),

   345                 "persistentPortInitialized", Boolean.FALSE,

   346                 Boolean.TRUE, "2743" ),

   347             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

   348                 OperationFactory.integerAction(),

   349                 "persistentServerId", new Integer( 0 ),

   350                 new Integer( 294 ), "294" ),

   351             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

   352                 OperationFactory.setFlagAction(),

   353                 "persistentServerIdInitialized", Boolean.FALSE,

   354                 Boolean.TRUE, "294" ),

   355             ParserDataFactory.make( ORBConstants.SERVER_ID_PROPERTY,

   356                 OperationFactory.setFlagAction(),

   357                 "orbServerIdPropertySpecified", Boolean.FALSE,

   358                 Boolean.TRUE, "294" ),

   359             ParserDataFactory.make( ORBConstants.ACTIVATED_PROPERTY,

   360                 OperationFactory.booleanAction(),

   361                 "serverIsORBActivated", Boolean.FALSE,

   362                 Boolean.TRUE, "true" ),

   363             ParserDataFactory.make( ORBConstants.BAD_SERVER_ID_HANDLER_CLASS_PROPERTY,

   364                 OperationFactory.classAction(),

   365                 "badServerIdHandlerClass", null,

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

   367             ParserDataFactory.make( ORBConstants.PI_ORB_INITIALIZER_CLASS_PREFIX,

   368                 makeROIOperation(),

   369                 "orbInitializers", new ORBInitializer[0],

   370                 TestORBInitializers, TestORBInitData, ORBInitializer.class ),

   371             ParserDataFactory.make( ORBConstants.ACCEPTOR_CLASS_PREFIX_PROPERTY,

   372                 makeAcceptorInstantiationOperation(),

   373                 "acceptors", new Acceptor[0],

   374                 TestAcceptors, TestAcceptorData, Acceptor.class ),

   376             //

   377             // Socket/Channel control

   378             //

   380             // Acceptor:

   381             // useNIOSelector == true

   382             //   useSelectThreadToWait = true

   383             //   useWorkerThreadForEvent = false

   384             // else

   385             //   useSelectThreadToWait = false

   386             //   useWorkerThreadForEvent = true

   388             // Connection:

   389             // useNIOSelector == true

   390             //   useSelectThreadToWait = true

   391             //   useWorkerThreadForEvent = true

   392             // else

   393             //   useSelectThreadToWait = false

   394             //   useWorkerThreadForEvent = true

   396             ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_TYPE_PROPERTY,

   397                 OperationFactory.stringAction(),

   398                 "acceptorSocketType", ORBConstants.SOCKETCHANNEL,

   399                 "foo", "foo" ),

   401             ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,

   402                 OperationFactory.booleanAction(),

   403                 "acceptorSocketUseSelectThreadToWait", Boolean.TRUE,

   404                 Boolean.TRUE, "true" ),

   405             ParserDataFactory.make( ORBConstants.ACCEPTOR_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,

   406                 OperationFactory.booleanAction(),

   407                 "acceptorSocketUseWorkerThreadForEvent", Boolean.TRUE,

   408                 Boolean.TRUE, "true" ),

   409             ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_TYPE_PROPERTY,

   410                 OperationFactory.stringAction(),

   411                 "connectionSocketType", ORBConstants.SOCKETCHANNEL,

   412                 "foo", "foo" ),

   413             ParserDataFactory.make( ORBConstants.USE_NIO_SELECT_TO_WAIT_PROPERTY,

   414                 OperationFactory.booleanAction(),

   415                 "connectionSocketUseSelectThreadToWait", Boolean.TRUE,

   416                 Boolean.TRUE, "true" ),

   417             ParserDataFactory.make( ORBConstants.CONNECTION_SOCKET_USE_WORKER_THREAD_FOR_EVENT_PROPERTY,

   418                 OperationFactory.booleanAction(),

   419                 "connectionSocketUseWorkerThreadForEvent", Boolean.TRUE,

   420                 Boolean.TRUE, "true" ),

   421             ParserDataFactory.make( ORBConstants.DISABLE_DIRECT_BYTE_BUFFER_USE_PROPERTY,

   422                 OperationFactory.booleanAction(),

   423                 "disableDirectByteBufferUse", Boolean.FALSE,

   424                 Boolean.TRUE, "true" ),

   425             ParserDataFactory.make(ORBConstants.TRANSPORT_TCP_READ_TIMEOUTS_PROPERTY,

   426                 makeTTCPRTOperation(),

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

   428                     ORBConstants.TRANSPORT_TCP_INITIAL_TIME_TO_WAIT,

   429                     ORBConstants.TRANSPORT_TCP_MAX_TIME_TO_WAIT,

   430                     ORBConstants.TRANSPORT_TCP_GIOP_HEADER_MAX_TIME_TO_WAIT,

   431                     ORBConstants.TRANSPORT_TCP_TIME_TO_WAIT_BACKOFF_FACTOR),

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

   433             ParserDataFactory.make(

   434                 ORBConstants.ENABLE_JAVA_SERIALIZATION_PROPERTY,

   435                 OperationFactory.booleanAction(),

   436                 "enableJavaSerialization", Boolean.FALSE,

   437                 Boolean.FALSE, "false"),

   438             ParserDataFactory.make(

   439                 ORBConstants.USE_REP_ID,

   440                 OperationFactory.booleanAction(),

   441                 "useRepId", Boolean.TRUE,

   442                 Boolean.TRUE, "true"),

   443             ParserDataFactory.make( ORBConstants.ORB_INIT_REF_PROPERTY,

   444                 OperationFactory.identityAction(),

   445                 "orbInitialReferences", new StringPair[0],

   446                 TestORBInitRefData, TestORBInitRefData, StringPair.class )

   447         } ;

   449         parserData = pd ;

   450     }

   452     public final class TestBadServerIdHandler implements BadServerIdHandler

   453     {

   454         public boolean equals( Object other )

   455         {

   456             return other instanceof TestBadServerIdHandler ;

   457         }

   459         public int hashCode() {

   460             return 1;

   461         }

   463         public void handle( ObjectKey objectKey )

   464         {

   465         }

   466     }

   468     private Operation makeTTCPRTOperation()

   469     {

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

   471                                 OperationFactory.integerAction(),

   472                                 OperationFactory.integerAction(),

   473                                 OperationFactory.integerAction() } ;

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

   477         Operation rtOp = new Operation() {

   478             public Object operate(Object value)

   479             {

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

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

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

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

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

   485                 return TransportDefault.makeReadTimeoutsFactory().create(

   486                                                    initialTime.intValue(),

   487                                                    maxGIOPHdrTime.intValue(),

   488                                                    maxGIOPBodyTime.intValue(),

   489                                                    backoffPercent.intValue());

   490             }

   491         } ;

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

   494         return ttcprtOp;

   495     }

   497     private Operation makeUSLOperation()

   498     {

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

   500             OperationFactory.integerAction() } ;

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

   503         Operation uslop = new Operation() {

   504             public Object operate( Object value )

   505             {

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

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

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

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

   510             }

   511         } ;

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

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

   515         return listenop ;

   516     }

   518     public static final class TestLegacyORBSocketFactory

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

   520     {

   521         public boolean equals( Object other )

   522         {

   523             return other instanceof TestLegacyORBSocketFactory ;

   524         }

   526         public int hashCode() {

   527             return 1;

   528         }

   530         public ServerSocket createServerSocket( String type, int port )

   531         {

   532             return null ;

   533         }

   535         public SocketInfo getEndPointInfo( org.omg.CORBA.ORB orb,

   536             IOR ior, SocketInfo socketInfo )

   537         {

   538             return null ;

   539         }

   541         public Socket createSocket( SocketInfo socketInfo )

   542         {

   543             return null ;

   544         }

   545     }

   547     public static final class TestORBSocketFactory

   548         implements com.sun.corba.se.spi.transport.ORBSocketFactory

   549     {

   550         public boolean equals( Object other )

   551         {

   552             return other instanceof TestORBSocketFactory ;

   553         }

   555         public int hashCode() {

   556             return 1;

   557         }

   559         public void setORB(ORB orb)

   560         {

   561         }

   563         public ServerSocket createServerSocket( String type, InetSocketAddress a )

   564         {

   565             return null ;

   566         }

   568         public Socket createSocket( String type, InetSocketAddress a )

   569         {

   570             return null ;

   571         }

   573         public void setAcceptedSocketOptions(Acceptor acceptor,

   574                                              ServerSocket serverSocket,

   575                                              Socket socket)

   576         {

   577         }

   578     }

   580     public static final class TestIORToSocketInfo

   581         implements IORToSocketInfo

   582     {

   583         public boolean equals( Object other )

   584         {

   585             return other instanceof TestIORToSocketInfo;

   586         }

   588         public int hashCode() {

   589             return 1;

   590         }

   592         public List getSocketInfo(IOR ior)

   593         {

   594             return null;

   595         }

   596     }

   598     public static final class TestIIOPPrimaryToContactInfo

   599         implements IIOPPrimaryToContactInfo

   600     {

   601         public void reset(ContactInfo primary)

   602         {

   603         }

   605         public boolean hasNext(ContactInfo primary,

   606                                ContactInfo previous,

   607                                List contactInfos)

   608         {

   609             return true;

   610         }

   612         public ContactInfo next(ContactInfo primary,

   613                                 ContactInfo previous,

   614                                 List contactInfos)

   615         {

   616             return null;

   617         }

   618     }

   620     public static final class TestContactInfoListFactory

   621         implements CorbaContactInfoListFactory

   622     {

   623         public boolean equals( Object other )

   624         {

   625             return other instanceof TestContactInfoListFactory;

   626         }

   628         public int hashCode() {

   629             return 1;

   630         }

   632         public void setORB(ORB orb) { }

   634         public CorbaContactInfoList create( IOR ior ) { return null; }

   635     }

   637     private Operation makeMapOperation( final Map map )

   638     {

   639         return new Operation() {

   640             public Object operate( Object value )

   641             {

   642                 return map.get( value ) ;

   643             }

   644         } ;

   645     }

   647     private Operation makeBMGROperation()

   648     {

   649         Map map = new HashMap() ;

   650         map.put( "GROW", new Integer(0) ) ;

   651         map.put( "CLCT", new Integer(1) ) ;

   652         map.put( "STRM", new Integer(2) ) ;

   653         return makeMapOperation( map ) ;

   654     }

   656     private Operation makeLegacySocketFactoryOperation()

   657     {

   658         Operation sfop = new Operation() {

   659             public Object operate( Object value )

   660             {

   661                 String param = (String)value ;

   663                 try {

   664                     Class<?> legacySocketFactoryClass =

   665                         SharedSecrets.getJavaCorbaAccess().loadClass(param);

   666                     // For security reasons avoid creating an instance if

   667                     // this socket factory class is not one that would fail

   668                     // the class cast anyway.

   669                     if (com.sun.corba.se.spi.legacy.connection.ORBSocketFactory.class.isAssignableFrom(legacySocketFactoryClass)) {

   670                         return legacySocketFactoryClass.newInstance();

   671                     } else {

   672                         throw wrapper.illegalSocketFactoryType( legacySocketFactoryClass.toString() ) ;

   673                     }

   674                 } catch (Exception ex) {

   675                     // ClassNotFoundException, IllegalAccessException,

   676                     // InstantiationException, SecurityException or

   677                     // ClassCastException

   678                     throw wrapper.badCustomSocketFactory( ex, param ) ;

   679                 }

   680             }

   681         } ;

   683         return sfop ;

   684     }

   686     private Operation makeSocketFactoryOperation()

   687     {

   688         Operation sfop = new Operation() {

   689             public Object operate( Object value )

   690             {

   691                 String param = (String)value ;

   693                 try {

   694                     Class<?> socketFactoryClass =

   695                         SharedSecrets.getJavaCorbaAccess().loadClass(param);

   696                     // For security reasons avoid creating an instance if

   697                     // this socket factory class is not one that would fail

   698                     // the class cast anyway.

   699                     if (com.sun.corba.se.spi.transport.ORBSocketFactory.class.isAssignableFrom(socketFactoryClass)) {

   700                         return socketFactoryClass.newInstance();

   701                     } else {

   702                         throw wrapper.illegalSocketFactoryType( socketFactoryClass.toString() ) ;

   703                     }

   704                 } catch (Exception ex) {

   705                     // ClassNotFoundException, IllegalAccessException,

   706                     // InstantiationException, SecurityException or

   707                     // ClassCastException

   708                     throw wrapper.badCustomSocketFactory( ex, param ) ;

   709                 }

   710             }

   711         } ;

   713         return sfop ;

   714     }

   716     private Operation makeIORToSocketInfoOperation()

   717     {

   718         Operation op = new Operation() {

   719             public Object operate( Object value )

   720             {

   721                 String param = (String)value ;

   723                 try {

   724                     Class<?> iorToSocketInfoClass =

   725                         SharedSecrets.getJavaCorbaAccess().loadClass(param);

   726                     // For security reasons avoid creating an instance if

   727                     // this socket factory class is not one that would fail

   728                     // the class cast anyway.

   729                     if (IORToSocketInfo.class.isAssignableFrom(iorToSocketInfoClass)) {

   730                         return iorToSocketInfoClass.newInstance();

   731                     } else {

   732                         throw wrapper.illegalIorToSocketInfoType( iorToSocketInfoClass.toString() ) ;

   733                     }

   734                 } catch (Exception ex) {

   735                     // ClassNotFoundException, IllegalAccessException,

   736                     // InstantiationException, SecurityException or

   737                     // ClassCastException

   738                     throw wrapper.badCustomIorToSocketInfo( ex, param ) ;

   739                 }

   740             }

   741         } ;

   743         return op ;

   744     }

   746     private Operation makeIIOPPrimaryToContactInfoOperation()

   747     {

   748         Operation op = new Operation() {

   749             public Object operate( Object value )

   750             {

   751                 String param = (String)value ;

   753                 try {

   754                     Class<?> iiopPrimaryToContactInfoClass =

   755                         SharedSecrets.getJavaCorbaAccess().loadClass(param);

   756                     // For security reasons avoid creating an instance if

   757                     // this socket factory class is not one that would fail

   758                     // the class cast anyway.

   759                     if (IIOPPrimaryToContactInfo.class.isAssignableFrom(iiopPrimaryToContactInfoClass)) {

   760                         return iiopPrimaryToContactInfoClass.newInstance();

   761                     } else {

   762                         throw wrapper.illegalIiopPrimaryToContactInfoType( iiopPrimaryToContactInfoClass.toString() ) ;

   763                     }

   764                 } catch (Exception ex) {

   765                     // ClassNotFoundException, IllegalAccessException,

   766                     // InstantiationException, SecurityException or

   767                     // ClassCastException

   768                     throw wrapper.badCustomIiopPrimaryToContactInfo( ex, param ) ;

   769                 }

   770             }

   771         } ;

   773         return op ;

   774     }

   776     private Operation makeContactInfoListFactoryOperation()

   777     {

   778         Operation op = new Operation() {

   779             public Object operate( Object value )

   780             {

   781                 String param = (String)value ;

   783                 try {

   784                     Class<?> contactInfoListFactoryClass =

   785                         SharedSecrets.getJavaCorbaAccess().loadClass(param);

   786                     // For security reasons avoid creating an instance if

   787                     // this socket factory class is not one that would fail

   788                     // the class cast anyway.

   789                     if (CorbaContactInfoListFactory.class.isAssignableFrom(

   790                         contactInfoListFactoryClass)) {

   791                         return contactInfoListFactoryClass.newInstance();

   792                     } else {

   793                         throw wrapper.illegalContactInfoListFactoryType(

   794                             contactInfoListFactoryClass.toString() ) ;

   795                     }

   796                 } catch (Exception ex) {

   797                     // ClassNotFoundException, IllegalAccessException,

   798                     // InstantiationException, SecurityException or

   799                     // ClassCastException

   800                     throw wrapper.badContactInfoListFactory( ex, param ) ;

   801                 }

   802             }

   803         } ;

   805         return op ;

   806     }

   808     private Operation makeCSOperation()

   809     {

   810         Operation csop = new Operation() {

   811             public Object operate( Object value )

   812             {

   813                 String val = (String)value ;

   814                 return CodeSetComponentInfo.createFromString( val ) ;

   815             }

   816         } ;

   818         return csop ;

   819     }

   821     private Operation makeADOperation()

   822     {

   823         Operation admap = new Operation() {

   824             private Integer[] map = {

   825                 new Integer( KeyAddr.value ),

   826                 new Integer( ProfileAddr.value ),

   827                 new Integer( ReferenceAddr.value ),

   828                 new Integer( KeyAddr.value ) } ;

   830             public Object operate( Object value )

   831             {

   832                 int val = ((Integer)value).intValue() ;

   833                 return map[val] ;

   834             }

   835         } ;

   837         Operation rangeop = OperationFactory.integerRangeAction( 0, 3 ) ;

   838         Operation op1 = OperationFactory.compose( rangeop, admap ) ;

   839         Operation result = OperationFactory.compose( op1, OperationFactory.convertIntegerToShort() ) ;

   840         return result ;

   841     }

   843     private Operation makeFSOperation() {

   844         Operation fschecker = new Operation() {

   845             public Object operate( Object value )

   846             {

   847                 int giopFragmentSize = ((Integer)value).intValue() ;

   848                 if (giopFragmentSize < ORBConstants.GIOP_FRAGMENT_MINIMUM_SIZE){

   849                     throw wrapper.fragmentSizeMinimum( new Integer( giopFragmentSize ),

   850                         new Integer( ORBConstants.GIOP_FRAGMENT_MINIMUM_SIZE ) ) ;

   851                 }

   853                 if (giopFragmentSize % ORBConstants.GIOP_FRAGMENT_DIVISOR != 0)

   854                     throw wrapper.fragmentSizeDiv( new Integer( giopFragmentSize ),

   855                             new Integer( ORBConstants.GIOP_FRAGMENT_DIVISOR ) ) ;

   857                 return value ;

   858             }

   859         } ;

   861         Operation result = OperationFactory.compose( OperationFactory.integerAction(),

   862             fschecker ) ;

   863         return result ;

   864     }

   866     private Operation makeGVOperation() {

   867         Operation gvHelper = OperationFactory.listAction( ".",

   868             OperationFactory.integerAction() ) ;

   869         Operation gvMain = new Operation() {

   870             public Object operate( Object value )

   871             {

   872                 Object[] nums = (Object[])value ;

   873                 int major = ((Integer)(nums[0])).intValue() ;

   874                 int minor = ((Integer)(nums[1])).intValue() ;

   876                 return new GIOPVersion( major, minor ) ;

   877             }

   878         } ;

   880         Operation result = OperationFactory.compose( gvHelper, gvMain );

   881         return result ;

   882     }

   884     public static final class TestORBInitializer1 extends org.omg.CORBA.LocalObject

   885         implements ORBInitializer

   886     {

   887         public boolean equals( Object other )

   888         {

   889             return other instanceof TestORBInitializer1 ;

   890         }

   892         public int hashCode() {

   893             return 1;

   894         }

   896         public void pre_init( ORBInitInfo info )

   897         {

   898         }

   900         public void post_init( ORBInitInfo info )

   901         {

   902         }

   903     }

   905     public static final class TestORBInitializer2 extends org.omg.CORBA.LocalObject

   906         implements ORBInitializer

   907     {

   908         public boolean equals( Object other )

   909         {

   910             return other instanceof TestORBInitializer2 ;

   911         }

   913         public int hashCode() {

   914             return 1;

   915         }

   917         public void pre_init( ORBInitInfo info )

   918         {

   919         }

   921         public void post_init( ORBInitInfo info )

   922         {

   923         }

   924     }

   926     private Operation makeROIOperation() {

   927         Operation clsop = OperationFactory.classAction() ;

   928         Operation indexOp = OperationFactory.suffixAction() ;

   929         Operation op1 = OperationFactory.compose( indexOp, clsop ) ;

   930         Operation mop = OperationFactory.maskErrorAction( op1 ) ;

   932         Operation mkinst = new Operation() {

   933             public Object operate( Object value )

   934             {

   935                 final Class initClass = (Class)value ;

   936                 if (initClass == null)

   937                     return null ;

   939                 // For security reasons avoid creating an instance

   940                 // if this class is one that would fail the class cast

   941                 // to ORBInitializer anyway.

   942                 if( org.omg.PortableInterceptor.ORBInitializer.class.isAssignableFrom(

   943                     initClass ) ) {

   944                     // Now that we have a class object, instantiate one and

   945                     // remember it:

   946                     ORBInitializer initializer = null ;

   948                     try {

   949                         initializer = (ORBInitializer)AccessController.doPrivileged(

   950                             new PrivilegedExceptionAction() {

   951                                 public Object run()

   952                                     throws InstantiationException, IllegalAccessException

   953                                 {

   954                                     return initClass.newInstance() ;

   955                                 }

   956                             }

   957                         ) ;

   958                     } catch (PrivilegedActionException exc) {

   959                         // Unwrap the exception, as we don't care exc here

   960                         throw wrapper.orbInitializerFailure( exc.getException(),

   961                             initClass.getName() ) ;

   962                     } catch (Exception exc) {

   963                         throw wrapper.orbInitializerFailure( exc, initClass.getName() ) ;

   964                     }

   966                     return initializer ;

   967                 } else {

   968                     throw wrapper.orbInitializerType( initClass.getName() ) ;

   969                 }

   970             }

   971         } ;

   973         Operation result = OperationFactory.compose( mop, mkinst ) ;

   975         return result ;

   976     }

   978     public static final class TestAcceptor1

   979         implements Acceptor

   980     {

   981         public boolean equals( Object other )

   982         {

   983             return other instanceof TestAcceptor1 ;

   984         }

   986         public int hashCode() { return 1; }

   987         public boolean initialize() { return true; }

   988         public boolean initialized() { return true; }

   989         public String getConnectionCacheType() { return "FOO"; }

   990         public void setConnectionCache(InboundConnectionCache connectionCache){}

   991         public InboundConnectionCache getConnectionCache() { return null; }

   992         public boolean shouldRegisterAcceptEvent() { return true; }

   993         public void setUseSelectThreadForConnections(boolean x) { }

   994         public boolean shouldUseSelectThreadForConnections() { return true; }

   995         public void setUseWorkerThreadForConnections(boolean x) { }

   996         public boolean shouldUseWorkerThreadForConnections() { return true; }

   997         public void accept() { }

   998         public void close() { }

   999         public EventHandler getEventHandler() { return null; }

  1000         public MessageMediator createMessageMediator(

  1001             Broker xbroker, Connection xconnection) { return null; }

  1002         public MessageMediator finishCreatingMessageMediator(

  1003             Broker xbroker, Connection xconnection,

  1004             MessageMediator messageMediator) { return null; }

  1005         public InputObject createInputObject(

  1006             Broker broker, MessageMediator messageMediator) { return null; }

  1007         public OutputObject createOutputObject(

  1008             Broker broker, MessageMediator messageMediator) { return null; }

  1009     }

  1011     public static final class TestAcceptor2

  1012         implements Acceptor

  1013     {

  1014         public boolean equals( Object other )

  1015         {

  1016             return other instanceof TestAcceptor2 ;

  1017         }

  1018         public int hashCode() { return 1; }

  1019         public boolean initialize() { return true; }

  1020         public boolean initialized() { return true; }

  1021         public String getConnectionCacheType() { return "FOO"; }

  1022         public void setConnectionCache(InboundConnectionCache connectionCache){}

  1023         public InboundConnectionCache getConnectionCache() { return null; }

  1024         public boolean shouldRegisterAcceptEvent() { return true; }

  1025         public void setUseSelectThreadForConnections(boolean x) { }

  1026         public boolean shouldUseSelectThreadForConnections() { return true; }

  1027         public void setUseWorkerThreadForConnections(boolean x) { }

  1028         public boolean shouldUseWorkerThreadForConnections() { return true; }

  1029         public void accept() { }

  1030         public void close() { }

  1031         public EventHandler getEventHandler() { return null; }

  1032         public MessageMediator createMessageMediator(

  1033             Broker xbroker, Connection xconnection) { return null; }

  1034         public MessageMediator finishCreatingMessageMediator(

  1035             Broker xbroker, Connection xconnection,

  1036             MessageMediator messageMediator) { return null; }

  1037         public InputObject createInputObject(

  1038             Broker broker, MessageMediator messageMediator) { return null; }

  1039         public OutputObject createOutputObject(

  1040             Broker broker, MessageMediator messageMediator) { return null; }

  1041     }

  1043     // REVISIT - this is a cut and paste modification of makeROIOperation.

  1044     private Operation makeAcceptorInstantiationOperation() {

  1045         Operation clsop = OperationFactory.classAction() ;

  1046         Operation indexOp = OperationFactory.suffixAction() ;

  1047         Operation op1 = OperationFactory.compose( indexOp, clsop ) ;

  1048         Operation mop = OperationFactory.maskErrorAction( op1 ) ;

  1050         Operation mkinst = new Operation() {

  1051             public Object operate( Object value )

  1052             {

  1053                 final Class initClass = (Class)value ;

  1054                 if (initClass == null)

  1055                     return null ;

  1057                 // For security reasons avoid creating an instance

  1058                 // if this class is one that would fail the class cast

  1059                 // to ORBInitializer anyway.

  1060                 if( Acceptor.class.isAssignableFrom( initClass ) ) {

  1061                     // Now that we have a class object, instantiate one and

  1062                     // remember it:

  1063                     Acceptor acceptor = null ;

  1065                     try {

  1066                         acceptor = (Acceptor)AccessController.doPrivileged(

  1067                             new PrivilegedExceptionAction() {

  1068                                 public Object run()

  1069                                     throws InstantiationException, IllegalAccessException

  1070                                 {

  1071                                     return initClass.newInstance() ;

  1072                                 }

  1073                             }

  1074                         ) ;

  1075                     } catch (PrivilegedActionException exc) {

  1076                         // Unwrap the exception, as we don't care exc here

  1077                         throw wrapper.acceptorInstantiationFailure( exc.getException(),

  1078                             initClass.getName() ) ;

  1079                     } catch (Exception exc) {

  1080                         throw wrapper.acceptorInstantiationFailure( exc, initClass.getName() ) ;

  1081                     }

  1083                     return acceptor ;

  1084                 } else {

  1085                     throw wrapper.acceptorInstantiationTypeFailure( initClass.getName() ) ;

  1086                 }

  1087             }

  1088         } ;

  1090         Operation result = OperationFactory.compose( mop, mkinst ) ;

  1092         return result ;

  1093     }

  1095     private Operation makeInitRefOperation() {

  1096         return new Operation() {

  1097             public Object operate( Object value )

  1098             {

  1099                 // Object is String[] of length 2.

  1100                 String[] values = (String[])value ;

  1101                 if (values.length != 2)

  1102                     throw wrapper.orbInitialreferenceSyntax() ;

  1104                 return values[0] + "=" + values[1] ;

  1105             }

  1106         } ;

  1107     }

  1108 }

  1110 // End of file.

Mercurial > jdk8-mips64-public > corba / file revision

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java@bfd167e38830

src/share/classes/com/sun/corba/se/impl/orb/ParserTable.java