1. /*

  2.  * @(#)MessageBase.java	1.19 04/06/21

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.corba.se.impl.protocol.giopmsgheaders;

  9. 

  10. import java.io.IOException;

  11. import java.lang.Class;

  12. import java.lang.reflect.Constructor;

  13. import java.nio.ByteBuffer;

  14. import java.util.Iterator;

  15. 

  16. import org.omg.CORBA.CompletionStatus;

  17. import org.omg.CORBA.INTERNAL;

  18. import org.omg.CORBA.MARSHAL;

  19. import org.omg.CORBA.Principal;

  20. import org.omg.CORBA.SystemException;

  21. import org.omg.IOP.TaggedProfile;

  22. 

  23. import com.sun.corba.se.pept.transport.ByteBufferPool;

  24. 

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

  26. import com.sun.corba.se.spi.ior.ObjectId;

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

  28. import com.sun.corba.se.spi.ior.ObjectKeyFactory;

  29. import com.sun.corba.se.spi.ior.iiop.IIOPProfile;

  30. import com.sun.corba.se.spi.ior.iiop.IIOPFactories;

  31. import com.sun.corba.se.spi.ior.iiop.IIOPProfileTemplate ;

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

  33. import com.sun.corba.se.spi.ior.iiop.RequestPartitioningComponent;

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

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

  36. import com.sun.corba.se.spi.transport.CorbaConnection;

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

  38. 

  39. import com.sun.corba.se.spi.servicecontext.ServiceContexts;

  40. import com.sun.corba.se.impl.encoding.ByteBufferWithInfo;

  41. import com.sun.corba.se.impl.encoding.CDRInputStream_1_0;

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

  43. import com.sun.corba.se.impl.orbutil.ORBUtility;

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

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

  46. import com.sun.corba.se.impl.protocol.AddressingDispositionException;

  47. 

  48. /**

  49.  * This class acts as the base class for the various GIOP message types. This

  50.  * also serves as a factory to create various message types. We currently

  51.  * support GIOP 1.0, 1.1 and 1.2 message types.

  52.  *

  53.  * @author Ram Jeyaraman 05/14/2000

  54.  * @version 1.0

  55.  */

  56. 

  57. public abstract class MessageBase implements Message{

  58. 

  59.     // This is only used when the giopDebug flag is

  60.     // turned on.

  61.     public byte[] giopHeader;

  62.     private ByteBuffer byteBuffer;

  63.     private int threadPoolToUse;

  64. 

  65.     // (encodingVersion == 0x00) implies CDR encoding, 

  66.     // (encodingVersion >  0x00) implies Java serialization version.

  67.     byte encodingVersion = (byte) Message.CDR_ENC_VERSION;

  68. 

  69.     private static ORBUtilSystemException wrapper = 

  70. 	ORBUtilSystemException.get( CORBALogDomains.RPC_PROTOCOL ) ;

  71. 

  72.     // Static methods

  73. 

  74.     public static String typeToString(int type)

  75.     {

  76. 	return typeToString((byte)type);

  77.     }

  78. 

  79.     public static String typeToString(byte type)

  80.     {

  81. 	String result = type + "/";

  82. 	switch (type) {

  83. 	case GIOPRequest         : result += "GIOPRequest";         break;

  84. 	case GIOPReply           : result += "GIOPReply";           break;

  85. 	case GIOPCancelRequest   : result += "GIOPCancelRequest";   break;

  86. 	case GIOPLocateRequest   : result += "GIOPLocateRequest";   break;

  87. 	case GIOPLocateReply     : result += "GIOPLocateReply";     break;

  88. 	case GIOPCloseConnection : result += "GIOPCloseConnection"; break;

  89. 	case GIOPMessageError    : result += "GIOPMessageError";    break;

  90. 	case GIOPFragment        : result += "GIOPFragment";        break;

  91. 	default                  : result += "Unknown";             break;

  92. 	}

  93. 	return result;

  94.     }

  95. 

  96.     public static MessageBase readGIOPMessage(ORB orb, CorbaConnection connection)

  97.     {

  98. 	MessageBase msg = readGIOPHeader(orb, connection);

  99. 	msg = (MessageBase)readGIOPBody(orb, connection, (Message)msg);

  100. 	return msg;

  101.     }

  102. 

  103.     public static MessageBase readGIOPHeader(ORB orb, CorbaConnection connection)

  104.     {

  105.         MessageBase msg = null;

  106.         ReadTimeouts readTimeouts =

  107. 	                   orb.getORBData().getTransportTCPReadTimeouts();

  108. 

  109. 	ByteBuffer buf = null;

  110. 

  111. 	try {

  112. 	    buf = connection.read(GIOPMessageHeaderLength,

  113. 			  0, GIOPMessageHeaderLength,

  114. 			  readTimeouts.get_max_giop_header_time_to_wait());

  115. 	} catch (IOException e) {

  116. 	    throw wrapper.ioexceptionWhenReadingConnection(e);

  117. 	}

  118. 

  119.         if (orb.giopDebugFlag) {

  120.             // Since this is executed in debug mode only the overhead of

  121.             // using a View Buffer is not an issue. We'll also use a

  122.             // read-only View Buffer so we don't disturb the state of

  123.             // byteBuffer. 

  124.             dprint(".readGIOPHeader: " + typeToString(buf.get(7)));

  125. 	    dprint(".readGIOPHeader: GIOP header is: ");

  126.             ByteBuffer viewBuffer = buf.asReadOnlyBuffer();

  127.             viewBuffer.position(0).limit(GIOPMessageHeaderLength);

  128. 	    ByteBufferWithInfo bbwi = new ByteBufferWithInfo(orb,viewBuffer);

  129. 	    bbwi.buflen = GIOPMessageHeaderLength;

  130. 	    CDRInputStream_1_0.printBuffer(bbwi);

  131.         }

  132. 

  133.         // Sanity checks

  134. 

  135.         /*

  136.          * check for magic corruption

  137.          * check for version incompatibility

  138.          * check if fragmentation is allowed based on mesg type.

  139.             . 1.0 fragmentation disallowed; FragmentMessage is non-existent.

  140.             . 1.1 only {Request, Reply} msgs maybe fragmented.

  141.             . 1.2 only {Request, Reply, LocateRequest, LocateReply} msgs

  142.               maybe fragmented.

  143.         */

  144. 

  145.         int b1, b2, b3, b4;

  146. 

  147.         b1 = (buf.get(0) << 24) & 0xFF000000;

  148.         b2 = (buf.get(1) << 16) & 0x00FF0000;

  149.         b3 = (buf.get(2) << 8)  & 0x0000FF00;

  150.         b4 = (buf.get(3) << 0)  & 0x000000FF;

  151.         int magic = (b1 | b2 | b3 | b4);

  152. 

  153.         if (magic != GIOPBigMagic) {

  154.             // If Magic is incorrect, it is an error.

  155.             // ACTION : send MessageError and close the connection.

  156. 	    throw wrapper.giopMagicError( CompletionStatus.COMPLETED_MAYBE);

  157.         }

  158. 

  159. 	// Extract the encoding version from the request GIOP Version,

  160. 	// if it contains an encoding, and set GIOP version appropriately.

  161. 	// For Java serialization, we use GIOP Version 1.2 message format.

  162. 	byte requestEncodingVersion = Message.CDR_ENC_VERSION;

  163. 	if ((buf.get(4) == 0x0D) &&

  164. 	    (buf.get(5) <= Message.JAVA_ENC_VERSION) &&

  165. 	    (buf.get(5) > Message.CDR_ENC_VERSION) &&

  166. 	    orb.getORBData().isJavaSerializationEnabled()) {

  167. 	    // Entering this block means the request is using Java encoding,

  168. 	    // and the encoding version is <= this ORB's Java encoding version.

  169. 	    requestEncodingVersion = buf.get(5);

  170. 	    buf.put(4, (byte) 0x01);

  171. 	    buf.put(5, (byte) 0x02);

  172. 	}

  173. 

  174.         GIOPVersion orbVersion = orb.getORBData().getGIOPVersion();

  175. 

  176.         if (orb.giopDebugFlag) {

  177.             dprint(".readGIOPHeader: Message GIOP version: "

  178.                               + buf.get(4) + '.' + buf.get(5));

  179.             dprint(".readGIOPHeader: ORB Max GIOP Version: "

  180.                               + orbVersion);

  181.         }

  182. 

  183.         if ( (buf.get(4) > orbVersion.getMajor()) ||

  184.              ( (buf.get(4) == orbVersion.getMajor()) && (buf.get(5) > orbVersion.getMinor()) )

  185.             ) {

  186.             // For requests, sending ORB should use the version info

  187.             // published in the IOR or may choose to use a <= version

  188.             // for requests. If the version is greater than published version,

  189.             // it is an error.

  190. 

  191.             // For replies, the ORB should always receive a version it supports

  192.             // or less, but never greater (except for MessageError)

  193. 

  194.             // ACTION : Send back a MessageError() with the the highest version

  195.             // the server ORB supports, and close the connection.

  196.             if ( buf.get(7) != GIOPMessageError ) {

  197. 		throw wrapper.giopVersionError( CompletionStatus.COMPLETED_MAYBE);

  198.             }

  199.         }

  200. 

  201.         AreFragmentsAllowed(buf.get(4), buf.get(5), buf.get(6), buf.get(7));

  202. 

  203.         // create appropriate messages types

  204. 

  205.         switch (buf.get(7)) {

  206. 

  207.         case GIOPRequest:

  208.             if (orb.giopDebugFlag) {

  209.                 dprint(".readGIOPHeader: creating RequestMessage");

  210.             }

  211.             //msg = new RequestMessage(orb.giopDebugFlag);

  212.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  213.                 msg = new RequestMessage_1_0(orb);

  214.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  215.                 msg = new RequestMessage_1_1(orb);

  216.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  217.                 msg = new RequestMessage_1_2(orb);

  218.             } else {

  219. 		throw wrapper.giopVersionError(

  220. 		    CompletionStatus.COMPLETED_MAYBE);

  221.             }

  222.             break;

  223. 

  224.         case GIOPLocateRequest:

  225.             if (orb.giopDebugFlag) {

  226.                 dprint(".readGIOPHeader: creating LocateRequestMessage");

  227.             }

  228.             //msg = new LocateRequestMessage(orb.giopDebugFlag);

  229.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  230.                 msg = new LocateRequestMessage_1_0(orb);

  231.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  232.                 msg = new LocateRequestMessage_1_1(orb);

  233.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  234.                 msg = new LocateRequestMessage_1_2(orb);

  235.             } else {

  236. 		throw wrapper.giopVersionError(

  237. 		    CompletionStatus.COMPLETED_MAYBE);

  238.             }

  239.             break;

  240. 

  241.         case GIOPCancelRequest:

  242.             if (orb.giopDebugFlag) {

  243.                 dprint(".readGIOPHeader: creating CancelRequestMessage");

  244.             }

  245.             //msg = new CancelRequestMessage(orb.giopDebugFlag);

  246.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  247.                 msg = new CancelRequestMessage_1_0();

  248.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  249.                 msg = new CancelRequestMessage_1_1();

  250.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  251.                 msg = new CancelRequestMessage_1_2();

  252.             } else {

  253. 		throw wrapper.giopVersionError(

  254. 		    CompletionStatus.COMPLETED_MAYBE);

  255.             }

  256.             break;

  257. 

  258.         case GIOPReply:

  259.             if (orb.giopDebugFlag) {

  260.                 dprint(".readGIOPHeader: creating ReplyMessage");

  261.             }

  262.             //msg = new ReplyMessage(orb.giopDebugFlag);

  263.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  264.                 msg = new ReplyMessage_1_0(orb);

  265.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  266.                 msg = new ReplyMessage_1_1(orb);

  267.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  268.                 msg = new ReplyMessage_1_2(orb);

  269.             } else {

  270. 		throw wrapper.giopVersionError(

  271. 		    CompletionStatus.COMPLETED_MAYBE);

  272.             }

  273.             break;

  274. 

  275.         case GIOPLocateReply:

  276.             if (orb.giopDebugFlag) {

  277.                 dprint(".readGIOPHeader: creating LocateReplyMessage");

  278.             }

  279.             //msg = new LocateReplyMessage(orb.giopDebugFlag);

  280.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  281.                 msg = new LocateReplyMessage_1_0(orb);

  282.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  283.                 msg = new LocateReplyMessage_1_1(orb);

  284.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  285.                 msg = new LocateReplyMessage_1_2(orb);

  286.             } else {

  287. 		throw wrapper.giopVersionError(

  288. 		    CompletionStatus.COMPLETED_MAYBE);

  289.             }

  290.             break;

  291. 

  292.         case GIOPCloseConnection:

  293.         case GIOPMessageError:

  294.             if (orb.giopDebugFlag) {

  295.                 dprint(".readGIOPHeader: creating Message for CloseConnection or MessageError");

  296.             }

  297.             // REVISIT a MessageError  may contain the highest version server

  298.             // can support. In such a case, a new request may be made with the

  299.             // correct version or the connection be simply closed. Note the

  300.             // connection may have been closed by the server.

  301.             //msg = new Message(orb.giopDebugFlag);

  302.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  303.                 msg = new Message_1_0();

  304.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  305.                 msg = new Message_1_1();

  306.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  307.                 msg = new Message_1_1();

  308.             } else {

  309. 		throw wrapper.giopVersionError(

  310. 		    CompletionStatus.COMPLETED_MAYBE);

  311.             }

  312.             break;

  313. 

  314.         case GIOPFragment:

  315.             if (orb.giopDebugFlag) {

  316.                 dprint(".readGIOPHeader: creating FragmentMessage");

  317.             }

  318.             //msg = new FragmentMessage(orb.giopDebugFlag);

  319.             if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  320.                 // not possible (error checking done already)

  321.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x01) ) { // 1.1

  322.                 msg = new FragmentMessage_1_1();

  323.             } else if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x02) ) { // 1.2

  324.                 msg = new FragmentMessage_1_2();

  325.             } else {

  326. 		throw wrapper.giopVersionError(

  327. 		    CompletionStatus.COMPLETED_MAYBE);

  328.             }

  329.             break;

  330. 

  331.         default:

  332.             if (orb.giopDebugFlag)

  333.                 dprint(".readGIOPHeader: UNKNOWN MESSAGE TYPE: "

  334. 		       + buf.get(7));

  335.             // unknown message type ?

  336.             // ACTION : send MessageError and close the connection

  337. 	    throw wrapper.giopVersionError(

  338. 		CompletionStatus.COMPLETED_MAYBE);

  339.         }

  340. 

  341.         //

  342.         // Initialize the generic GIOP header instance variables.

  343.         //

  344. 

  345.         if ( (buf.get(4) == 0x01) && (buf.get(5) == 0x00) ) { // 1.0

  346.             Message_1_0 msg10 = (Message_1_0) msg;

  347.             msg10.magic = magic;

  348.             msg10.GIOP_version = new GIOPVersion(buf.get(4), buf.get(5));

  349.             msg10.byte_order = (buf.get(6) == LITTLE_ENDIAN_BIT);

  350. 	    // 'request partitioning' not supported on GIOP version 1.0

  351. 	    // so just use the default thread pool, 0.

  352. 	    msg.threadPoolToUse = 0;

  353.             msg10.message_type = buf.get(7);

  354.             msg10.message_size = readSize(buf.get(8), buf.get(9), buf.get(10), buf.get(11),

  355.                                           msg10.isLittleEndian()) +

  356.                                  GIOPMessageHeaderLength;

  357.         } else { // 1.1 & 1.2

  358.             Message_1_1 msg11 = (Message_1_1) msg;

  359.             msg11.magic = magic;

  360.             msg11.GIOP_version = new GIOPVersion(buf.get(4), buf.get(5));

  361.             msg11.flags = (byte)(buf.get(6) & TRAILING_TWO_BIT_BYTE_MASK);

  362. 	    // IMPORTANT: For 'request partitioning', the thread pool to use

  363. 	    //            information is stored in the leading 6 bits of byte 6.

  364. 	    //

  365. 	    // IMPORTANT: Request partitioning is a PROPRIETARY EXTENSION !!!

  366. 	    //

  367. 	    // NOTE: Bitwise operators will promote a byte to an int before 

  368. 	    //       performing a bitwise operation and bytes, ints, longs, etc

  369. 	    //       are signed types in Java. Thus, the need for the 

  370. 	    //       THREAD_POOL_TO_USE_MASK operation.

  371. 	    msg.threadPoolToUse = (buf.get(6) >>> 2) & THREAD_POOL_TO_USE_MASK;

  372.             msg11.message_type = buf.get(7);

  373.             msg11.message_size = 

  374.                       readSize(buf.get(8), buf.get(9), buf.get(10), buf.get(11),

  375.                               msg11.isLittleEndian()) + GIOPMessageHeaderLength;

  376.         }

  377. 

  378. 

  379.         if (orb.giopDebugFlag) {

  380.             // Since this is executed in debug mode only the overhead of

  381.             // using a View Buffer is not an issue. We'll also use a

  382.             // read-only View Buffer so we don't disturb the state of

  383.             // byteBuffer. 

  384.             dprint(".readGIOPHeader: header construction complete.");

  385. 

  386.             // For debugging purposes, save the 12 bytes of the header

  387.             ByteBuffer viewBuf = buf.asReadOnlyBuffer();

  388.             byte[] msgBuf = new byte[GIOPMessageHeaderLength];

  389.             viewBuf.position(0).limit(GIOPMessageHeaderLength);

  390.             viewBuf.get(msgBuf,0,msgBuf.length);

  391. 	    // REVISIT: is giopHeader still used?

  392.             ((MessageBase)msg).giopHeader = msgBuf;

  393.         }

  394. 

  395. 	msg.setByteBuffer(buf);

  396. 	msg.setEncodingVersion(requestEncodingVersion);

  397. 

  398. 	return msg;

  399.     }

  400. 

  401.     public static Message readGIOPBody(ORB orb,

  402. 			               CorbaConnection connection,

  403. 				       Message msg)

  404.     {

  405.         ReadTimeouts readTimeouts =

  406. 	                   orb.getORBData().getTransportTCPReadTimeouts();

  407. 	ByteBuffer buf = msg.getByteBuffer();

  408. 

  409. 	buf.position(MessageBase.GIOPMessageHeaderLength);

  410. 	int msgSizeMinusHeader =

  411. 	    msg.getSize() - MessageBase.GIOPMessageHeaderLength;

  412. 	try {

  413. 	    buf = connection.read(buf, 

  414. 			  GIOPMessageHeaderLength, msgSizeMinusHeader,

  415. 			  readTimeouts.get_max_time_to_wait());

  416. 	} catch (IOException e) {

  417. 	    throw wrapper.ioexceptionWhenReadingConnection(e);

  418. 	}

  419. 

  420. 	msg.setByteBuffer(buf);

  421. 

  422. 	if (orb.giopDebugFlag) {

  423. 	    dprint(".readGIOPBody: received message:");

  424. 	    ByteBuffer viewBuffer = buf.asReadOnlyBuffer();

  425. 	    viewBuffer.position(0).limit(msg.getSize());

  426. 	    ByteBufferWithInfo bbwi = new ByteBufferWithInfo(orb, viewBuffer);

  427. 	    CDRInputStream_1_0.printBuffer(bbwi);

  428. 	}

  429. 

  430.         return msg;

  431.     }

  432. 

  433.     private static RequestMessage createRequest(

  434.             ORB orb, GIOPVersion gv, byte encodingVersion, int request_id,

  435.             boolean response_expected, byte[] object_key, String operation,

  436.             ServiceContexts service_contexts, Principal requesting_principal) {

  437. 

  438.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  439.             return new RequestMessage_1_0(orb, service_contexts, request_id,

  440. 					 response_expected, object_key,

  441. 					 operation, requesting_principal);

  442.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  443.             return new RequestMessage_1_1(orb, service_contexts, request_id,

  444.                 response_expected, new byte[] { 0x00, 0x00, 0x00 },

  445.                 object_key, operation, requesting_principal);

  446.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  447.             // Note: Currently we use response_expected flag to decide if the

  448.             // call is oneway or not. Ideally, it is possible to expect a

  449.             // response on a oneway call too, but we do not support it now.

  450.             byte response_flags = 0x03;

  451.             if (response_expected) {

  452.                 response_flags = 0x03;

  453.             } else {

  454.                 response_flags = 0x00;

  455.             }

  456.             /*

  457.             // REVISIT The following is the correct way to do it. This gives

  458.             // more flexibility.

  459.             if ((DII::INV_NO_RESPONSE == false) && response_expected) {

  460.                 response_flags = 0x03; // regular two-way

  461.             } else if ((DII::INV_NO_RESPONSE == false) && !response_expected) {

  462.                 // this condition is not possible

  463.             } else if ((DII::INV_NO_RESPONSE == true) && response_expected) {

  464.                 // oneway, but we need response for LocationForwards or

  465.                 // SystemExceptions.

  466.                 response_flags = 0x01;

  467.             } else if ((DII::INV_NO_RESPONSE == true) && !response_expected) {

  468.                 // oneway, no response required

  469.                 response_flags = 0x00;

  470.             }

  471.             */

  472.             TargetAddress target = new TargetAddress();

  473.             target.object_key(object_key);

  474.             RequestMessage msg = 

  475. 		new RequestMessage_1_2(orb, request_id, response_flags,

  476. 				       new byte[] { 0x00, 0x00, 0x00 },

  477. 				       target, operation, service_contexts);

  478. 	    msg.setEncodingVersion(encodingVersion);

  479. 	    return msg;

  480.         } else {

  481. 	    throw wrapper.giopVersionError(

  482. 		CompletionStatus.COMPLETED_MAYBE);

  483.         }

  484.     }

  485. 

  486.     public static RequestMessage createRequest(

  487.             ORB orb, GIOPVersion gv, byte encodingVersion, int request_id,

  488. 	    boolean response_expected, IOR ior,

  489. 	    short addrDisp, String operation,

  490.             ServiceContexts service_contexts, Principal requesting_principal) {

  491. 

  492. 	RequestMessage requestMessage = null;

  493.         IIOPProfile profile = ior.getProfile();

  494.             

  495.         if (addrDisp == KeyAddr.value) {  

  496.             // object key will be used for target addressing

  497.             profile = ior.getProfile();

  498.     	    ObjectKey objKey = profile.getObjectKey();

  499. 	    byte[] object_key = objKey.getBytes(orb);            

  500. 	    requestMessage = 

  501. 		   createRequest(orb, gv, encodingVersion, request_id,

  502. 				 response_expected, object_key,

  503. 				 operation, service_contexts,

  504.                                  requesting_principal);            

  505.         } else {

  506.         

  507.             if (!(gv.equals(GIOPVersion.V1_2))) {        

  508.                 // only object_key based target addressing is allowed for 

  509.                 // GIOP 1.0 & 1.1

  510. 	        throw wrapper.giopVersionError(

  511. 		    CompletionStatus.COMPLETED_MAYBE);

  512.             }

  513.     

  514.             // Note: Currently we use response_expected flag to decide if the

  515.             // call is oneway or not. Ideally, it is possible to expect a

  516.             // response on a oneway call too, but we do not support it now.

  517.             byte response_flags = 0x03;

  518.             if (response_expected) {

  519.                 response_flags = 0x03;

  520.             } else {

  521.                 response_flags = 0x00;

  522.             }

  523.             

  524.             TargetAddress target = new TargetAddress();            

  525.             if (addrDisp == ProfileAddr.value) { // iop profile will be used

  526.                 profile = ior.getProfile();

  527.                 target.profile(profile.getIOPProfile());

  528.             } else if (addrDisp == ReferenceAddr.value) {  // ior will be used

  529.                 IORAddressingInfo iorInfo = 

  530.                     new IORAddressingInfo( 0, // profile index

  531.                         ior.getIOPIOR());

  532.                 target.ior(iorInfo);  

  533.             } else { 

  534.                 // invalid target addressing disposition value

  535. 	        throw wrapper.illegalTargetAddressDisposition(

  536. 		    CompletionStatus.COMPLETED_NO);

  537.             }

  538.         

  539. 	    requestMessage =

  540.                    new RequestMessage_1_2(orb, request_id, response_flags,

  541.                                   new byte[] { 0x00, 0x00, 0x00 }, target,

  542.                                   operation, service_contexts);

  543. 	    requestMessage.setEncodingVersion(encodingVersion);

  544. 	}

  545. 

  546. 	if (gv.supportsIORIIOPProfileComponents()) {

  547. 	    // add request partitioning thread pool to use info

  548. 	    int poolToUse = 0; // default pool

  549. 	    IIOPProfileTemplate temp = 

  550. 		(IIOPProfileTemplate)profile.getTaggedProfileTemplate();

  551. 	    Iterator iter = 

  552. 		temp.iteratorById(ORBConstants.TAG_REQUEST_PARTITIONING_ID);

  553. 	    if (iter.hasNext()) {

  554. 		poolToUse = 

  555. 		    ((RequestPartitioningComponent)iter.next()).getRequestPartitioningId();

  556. 	    }

  557. 

  558. 	    if (poolToUse < ORBConstants.REQUEST_PARTITIONING_MIN_THREAD_POOL_ID ||

  559. 		poolToUse > ORBConstants.REQUEST_PARTITIONING_MAX_THREAD_POOL_ID) {

  560. 		throw wrapper.invalidRequestPartitioningId(new Integer(poolToUse),

  561. 		      new Integer(ORBConstants.REQUEST_PARTITIONING_MIN_THREAD_POOL_ID),

  562. 	      	      new Integer(ORBConstants.REQUEST_PARTITIONING_MAX_THREAD_POOL_ID));

  563. 	    }

  564. 	    requestMessage.setThreadPoolToUse(poolToUse);

  565. 	}

  566. 

  567. 	return requestMessage;

  568.     }

  569.                     

  570.     public static ReplyMessage createReply(

  571.             ORB orb, GIOPVersion gv, byte encodingVersion, int request_id,

  572.             int reply_status, ServiceContexts service_contexts, IOR ior) {

  573. 

  574.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  575.             return new ReplyMessage_1_0(orb, service_contexts, request_id,

  576.                                         reply_status, ior);

  577.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  578.             return new ReplyMessage_1_1(orb, service_contexts, request_id,

  579.                                         reply_status, ior);

  580.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  581.             ReplyMessage msg = 

  582. 		new ReplyMessage_1_2(orb, request_id, reply_status,

  583. 				     service_contexts, ior);

  584. 	    msg.setEncodingVersion(encodingVersion);

  585. 	    return msg;

  586.         } else {

  587. 	    throw wrapper.giopVersionError(

  588. 		CompletionStatus.COMPLETED_MAYBE);

  589.         }

  590.     }

  591. 

  592.     public static LocateRequestMessage createLocateRequest(

  593.             ORB orb, GIOPVersion gv, byte encodingVersion,

  594.             int request_id, byte[] object_key) {

  595. 

  596.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  597.             return new LocateRequestMessage_1_0(orb, request_id, object_key);

  598.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  599.             return new LocateRequestMessage_1_1(orb, request_id, object_key);

  600.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  601.             TargetAddress target = new TargetAddress();

  602.             target.object_key(object_key);

  603.             LocateRequestMessage msg =

  604. 		new LocateRequestMessage_1_2(orb, request_id, target);

  605. 	    msg.setEncodingVersion(encodingVersion);

  606. 	    return msg;

  607.         } else {

  608. 	    throw wrapper.giopVersionError(

  609. 		CompletionStatus.COMPLETED_MAYBE);

  610.         }

  611.     }

  612. 

  613.     public static LocateReplyMessage createLocateReply(

  614. 	    ORB orb, GIOPVersion gv, byte encodingVersion,

  615.             int request_id, int locate_status, IOR ior) {

  616. 

  617.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  618.             return new LocateReplyMessage_1_0(orb, request_id,

  619.                                               locate_status, ior);

  620.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  621.             return new LocateReplyMessage_1_1(orb, request_id,

  622.                                               locate_status, ior);

  623.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  624.             LocateReplyMessage msg = 

  625. 		new LocateReplyMessage_1_2(orb, request_id, 

  626. 					   locate_status, ior);

  627. 	    msg.setEncodingVersion(encodingVersion);

  628. 	    return msg;

  629.         } else {

  630. 	    throw wrapper.giopVersionError(

  631. 		CompletionStatus.COMPLETED_MAYBE);

  632.         }

  633.     }

  634. 

  635.     public static CancelRequestMessage createCancelRequest(

  636.             GIOPVersion gv, int request_id) {

  637. 

  638.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  639.             return new CancelRequestMessage_1_0(request_id);

  640.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  641.             return new CancelRequestMessage_1_1(request_id);

  642.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  643.             return new CancelRequestMessage_1_2(request_id);

  644.         } else {

  645. 	    throw wrapper.giopVersionError(

  646. 		CompletionStatus.COMPLETED_MAYBE);

  647.         }

  648.     }

  649. 

  650.     public static Message createCloseConnection(GIOPVersion gv) {

  651.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  652.             return new Message_1_0(Message.GIOPBigMagic, false,

  653.                                    Message.GIOPCloseConnection, 0);

  654.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  655.             return new Message_1_1(Message.GIOPBigMagic, GIOPVersion.V1_1,

  656.                                    FLAG_NO_FRAG_BIG_ENDIAN,

  657.                                    Message.GIOPCloseConnection, 0);

  658.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  659.             return new Message_1_1(Message.GIOPBigMagic, GIOPVersion.V1_2,

  660.                                    FLAG_NO_FRAG_BIG_ENDIAN,

  661.                                    Message.GIOPCloseConnection, 0);

  662.         } else {

  663. 	    throw wrapper.giopVersionError(

  664. 		CompletionStatus.COMPLETED_MAYBE);

  665.         }

  666.     }

  667. 

  668.     public static Message createMessageError(GIOPVersion gv) {

  669.         if (gv.equals(GIOPVersion.V1_0)) { // 1.0

  670.             return new Message_1_0(Message.GIOPBigMagic, false,

  671.                                    Message.GIOPMessageError, 0);

  672.         } else if (gv.equals(GIOPVersion.V1_1)) { // 1.1

  673.             return new Message_1_1(Message.GIOPBigMagic, GIOPVersion.V1_1,

  674.                                    FLAG_NO_FRAG_BIG_ENDIAN,

  675.                                    Message.GIOPMessageError, 0);

  676.         } else if (gv.equals(GIOPVersion.V1_2)) { // 1.2

  677.             return new Message_1_1(Message.GIOPBigMagic, GIOPVersion.V1_2,

  678.                                    FLAG_NO_FRAG_BIG_ENDIAN,

  679.                                    Message.GIOPMessageError, 0);

  680.         } else {

  681. 	    throw wrapper.giopVersionError(

  682. 		CompletionStatus.COMPLETED_MAYBE);

  683.         }

  684.     }

  685. 

  686.     public static FragmentMessage createFragmentMessage(GIOPVersion gv) {

  687.         // This method is not currently used.

  688.         // New fragment messages are always created from existing messages.

  689.         // Creating a FragmentMessage from InputStream is done in

  690.         // createFromStream(..)

  691.         return null;

  692.     }

  693. 

  694.     public static int getRequestId(Message msg) {

  695.         switch (msg.getType()) {

  696.         case GIOPRequest :

  697.             return ((RequestMessage) msg).getRequestId();

  698.         case GIOPReply :

  699.             return ((ReplyMessage) msg).getRequestId();

  700.         case GIOPLocateRequest :

  701.             return ((LocateRequestMessage) msg).getRequestId();

  702.         case GIOPLocateReply :

  703.             return ((LocateReplyMessage) msg).getRequestId();

  704.         case GIOPCancelRequest :

  705.             return ((CancelRequestMessage) msg).getRequestId();

  706.         case GIOPFragment :

  707.             return ((FragmentMessage) msg).getRequestId();

  708.         }

  709. 

  710. 	throw wrapper.illegalGiopMsgType( 

  711. 	    CompletionStatus.COMPLETED_MAYBE);

  712.     }

  713. 

  714.     /**

  715.      * Set a flag in the given buffer (fragment bit, byte order bit, etc)

  716.      */

  717.     public static void setFlag(ByteBuffer byteBuffer, int flag) {

  718.         byte b = byteBuffer.get(6);

  719.         b |= flag;

  720.         byteBuffer.put(6,b);

  721.     }

  722. 

  723.     /**

  724.      * Clears a flag in the given buffer

  725.      */

  726.     public static void clearFlag(byte[] buf, int flag) {

  727.         buf[6] &= (0xFF ^ flag);

  728.     }

  729. 

  730.     private static void AreFragmentsAllowed(byte major, byte minor, byte flag,

  731.             byte msgType) {

  732. 

  733.         if ( (major == 0x01) && (minor == 0x00) ) { // 1.0

  734.             if (msgType == GIOPFragment) {

  735. 		throw wrapper.fragmentationDisallowed( 

  736. 		    CompletionStatus.COMPLETED_MAYBE);

  737.             }

  738.         }

  739. 

  740.         if ( (flag & MORE_FRAGMENTS_BIT) == MORE_FRAGMENTS_BIT ) {

  741.             switch (msgType) {

  742.             case GIOPCancelRequest :

  743.             case GIOPCloseConnection :

  744.             case GIOPMessageError :

  745. 		throw wrapper.fragmentationDisallowed( 

  746. 		    CompletionStatus.COMPLETED_MAYBE);

  747.             case GIOPLocateRequest :

  748.             case GIOPLocateReply :

  749.                 if ( (major == 0x01) && (minor == 0x01) ) { // 1.1

  750. 		    throw wrapper.fragmentationDisallowed( 

  751. 			CompletionStatus.COMPLETED_MAYBE);

  752.                 }

  753.                 break;

  754.             }

  755.         }

  756.     }

  757. 

  758.     /**

  759.      * Construct an ObjectKey from a byte[].

  760.      *

  761.      * @return ObjectKey the object key.

  762.      */

  763.     static ObjectKey extractObjectKey(byte[] objKey, ORB orb) {

  764. 

  765.         try {

  766.             if (objKey != null) {

  767.                 ObjectKey objectKey = 

  768. 		    orb.getObjectKeyFactory().create(objKey);

  769.                 if (objectKey != null) {

  770.                     return objectKey;

  771.                 }

  772.             }

  773.         } catch (Exception e) {

  774. 	    // XXX log this exception

  775. 	}

  776. 

  777. 	// This exception is thrown if any exceptions are raised while

  778. 	// extracting the object key or if the object key is empty.

  779. 	throw wrapper.invalidObjectKey();

  780.     }

  781. 

  782.     /**

  783.      * Extract the object key from TargetAddress.

  784.      *

  785.      * @return ObjectKey the object key.

  786.      */

  787.     static ObjectKey extractObjectKey(TargetAddress target, ORB orb) {

  788.     

  789.         short orbTargetAddrPref = orb.getORBData().getGIOPTargetAddressPreference();

  790.         short reqAddrDisp = target.discriminator();

  791.             

  792.         switch (orbTargetAddrPref) {

  793.         case ORBConstants.ADDR_DISP_OBJKEY :

  794.             if (reqAddrDisp != KeyAddr.value) {

  795.                 throw new AddressingDispositionException(KeyAddr.value);

  796.             }

  797.             break;

  798.         case ORBConstants.ADDR_DISP_PROFILE :

  799.             if (reqAddrDisp != ProfileAddr.value) {

  800.                 throw new AddressingDispositionException(ProfileAddr.value);

  801.             }

  802.             break;

  803.         case ORBConstants.ADDR_DISP_IOR :

  804.             if (reqAddrDisp != ReferenceAddr.value) {

  805.                 throw new AddressingDispositionException(ReferenceAddr.value);

  806.             }

  807.             break;

  808.         case ORBConstants.ADDR_DISP_HANDLE_ALL :

  809.             break;

  810.         default : 

  811. 	    throw wrapper.orbTargetAddrPreferenceInExtractObjectkeyInvalid() ;

  812.         }    

  813.         

  814.         try {

  815.             switch (reqAddrDisp) {

  816.             case KeyAddr.value :

  817.                 byte[] objKey = target.object_key();

  818.                 if (objKey != null) { // AddressingDisposition::KeyAddr

  819.                     ObjectKey objectKey = 

  820. 			orb.getObjectKeyFactory().create(objKey);

  821.                     if (objectKey != null) {

  822.                        return objectKey;

  823.                    }

  824.                 }

  825.                 break;

  826.             case ProfileAddr.value :

  827.                 IIOPProfile iiopProfile = null;

  828.                 TaggedProfile profile = target.profile();

  829.                 if (profile != null) { // AddressingDisposition::ProfileAddr

  830.                    iiopProfile = IIOPFactories.makeIIOPProfile(orb, profile);

  831.                    ObjectKey objectKey = iiopProfile.getObjectKey();

  832.                    if (objectKey != null) {

  833.                        return objectKey;

  834.                    }

  835.                 }

  836.                 break;

  837.             case ReferenceAddr.value :

  838.                 IORAddressingInfo iorInfo = target.ior();

  839.                 if (iorInfo != null) { // AddressingDisposition::IORAddr

  840.                     profile = iorInfo.ior.profiles[iorInfo.selected_profile_index];

  841.                     iiopProfile = IIOPFactories.makeIIOPProfile(orb, profile);

  842.                     ObjectKey objectKey = iiopProfile.getObjectKey();

  843.                     if (objectKey != null) {

  844.                        return objectKey;

  845.                    }

  846.                 }

  847.                 break;

  848.             default : // this cannot happen

  849.                 // There is no need for a explicit exception, since the

  850.                 // TargetAddressHelper.read() would have raised a BAD_OPERATION

  851.                 // exception by now.

  852.                 break;

  853.             }

  854.         } catch (Exception e) {}

  855. 

  856. 	// This exception is thrown if any exceptions are raised while

  857. 	// extracting the object key from the TargetAddress or if all the

  858. 	// the valid TargetAddress::AddressingDispositions are empty.

  859. 	throw wrapper.invalidObjectKey() ;

  860.     }

  861. 

  862.     private static int readSize(byte b1, byte b2, byte b3, byte b4,

  863.             boolean littleEndian) {

  864. 

  865.         int a1, a2, a3, a4;

  866. 

  867.         if (!littleEndian) {

  868.             a1 = (b1 << 24) & 0xFF000000;

  869.             a2 = (b2 << 16) & 0x00FF0000;

  870.             a3 = (b3 << 8)  & 0x0000FF00;

  871.             a4 = (b4 << 0)  & 0x000000FF;

  872.         } else {

  873.             a1 = (b4 << 24) & 0xFF000000;

  874.             a2 = (b3 << 16) & 0x00FF0000;

  875.             a3 = (b2 << 8)  & 0x0000FF00;

  876.             a4 = (b1 << 0)  & 0x000000FF;

  877.         }

  878. 

  879.         return (a1 | a2 | a3 | a4);

  880.     }

  881. 

  882.     static void nullCheck(Object obj) {

  883.         if (obj == null) {

  884. 	    throw wrapper.nullNotAllowed() ;

  885.         }

  886.     }

  887. 

  888.     static SystemException getSystemException(

  889.         String exClassName, int minorCode, CompletionStatus completionStatus,

  890. 	String message, ORBUtilSystemException wrapper)

  891.     {

  892. 	SystemException sysEx = null;

  893. 

  894.         try {

  895. 	    Class clazz = ORBClassLoader.loadClass(exClassName);

  896. 	    if (message == null) {

  897. 		sysEx = (SystemException) clazz.newInstance();

  898. 	    } else {

  899. 		Class[] types = { String.class };

  900. 		Constructor constructor = clazz.getConstructor(types);

  901. 		Object[] args = { message };

  902. 		sysEx = (SystemException)constructor.newInstance(args);

  903. 	    }

  904.         } catch (Exception someEx) {

  905. 	    throw wrapper.badSystemExceptionInReply( 

  906. 		CompletionStatus.COMPLETED_MAYBE, someEx );

  907.         }

  908. 

  909.         sysEx.minor = minorCode;

  910.         sysEx.completed = completionStatus;

  911. 

  912.         return sysEx;

  913.     }

  914. 

  915.     public void callback(MessageHandler handler)

  916.         throws java.io.IOException

  917.     {

  918.         handler.handleInput(this);

  919.     }

  920. 

  921.     public ByteBuffer getByteBuffer()

  922.     {

  923. 	return byteBuffer;

  924.     }

  925. 

  926.     public void setByteBuffer(ByteBuffer byteBuffer)

  927.     {

  928. 	this.byteBuffer = byteBuffer;

  929.     }

  930. 

  931.     public int getThreadPoolToUse()

  932.     {

  933. 	return threadPoolToUse;

  934.     }

  935. 

  936.     public byte getEncodingVersion() {

  937. 	return this.encodingVersion;

  938.     }

  939. 

  940.     public void setEncodingVersion(byte version) {

  941. 	this.encodingVersion = version;

  942.     }

  943. 

  944.     private static void dprint(String msg)

  945.     {

  946. 	ORBUtility.dprint("MessageBase", msg);

  947.     }

  948. }