Example #1
0
        public void TestGiopConnectionDescCodeSetNotSetAccess()
        {
            GiopConnectionDesc desc =
                new GiopConnectionDesc(null, null);

            Assert.IsTrue(
                !desc.IsCodeSetDefined(), "No codeset user defined at construction time");
            try
            {
                int charSet = desc.CharSet;
                Assert.Fail("Expected expection, when accessing charset, although not set");
            }
            catch (INTERNAL)
            {
                // expected.
            }
            try
            {
                int wcharSet = desc.WCharSet;
                Assert.Fail("Expected expection, when accessing charset, although not set");
            }
            catch (INTERNAL)
            {
                // expected.
            }
        }
Example #2
0
        /// <summary>reads an incoming Giop request-message from the Stream sourceStream</summary>
        /// <returns>the .NET request message created from this Giop-message</returns>
        internal IMessage ParseIncomingRequestMessage(Stream sourceStream,
                                                      GiopConnectionDesc conDesc)
        {
            CdrMessageInputStream msgInput = new CdrMessageInputStream(sourceStream);

            return(ParseIncomingRequestMessage(msgInput, conDesc));
        }
Example #3
0
 /// <summary>
 /// constructor for the in direction.
 /// </summary>
 internal GiopServerRequest(GiopConnectionDesc conDesc,
                            IInterceptionOption[] interceptionOptions)
 {
     m_requestMessage     = new SimpleGiopMsg();
     m_requestCallMessage = null; // not yet created; will be created from requestMessage later.
     m_replyMessage       = null; // not yet available
     m_conDesc            = conDesc;
     InitalizeForInterception(interceptionOptions);
 }
Example #4
0
        /// <summary>reads an incoming Giop request-message from the message input stream msgInput</summary>
        /// <returns>the .NET request message created from this Giop-message</returns>
        internal IMessage ParseIncomingRequestMessage(CdrMessageInputStream msgInput,
                                                      GiopConnectionDesc conDesc)
        {
            CdrInputStream msgBody = msgInput.GetMessageContentReadingStream();

            // deserialize the message body (the GIOP-request id is included in this message)
            return(m_ser.DeserialiseRequest(msgBody, msgInput.Header.Version,
                                            conDesc, m_interceptionOptions));
        }
Example #5
0
        public void TestGiopConnectionDescCodeSetNotSet()
        {
            GiopConnectionDesc desc =
                new GiopConnectionDesc(null, null);

            Assert.IsTrue(
                !desc.IsCodeSetNegotiated(), "Codeset not negotiated at construction time");
            Assert.IsTrue(
                !desc.IsCodeSetDefined(), "No codeset user defined at construction time");
        }
Example #6
0
        public void TestGiopConnectionDescSetCodeSetNegotiated()
        {
            GiopConnectionDesc desc =
                new GiopConnectionDesc(null, null);

            desc.SetCodeSetNegotiated();
            Assert.IsTrue(
                desc.IsCodeSetNegotiated(), "Codeset negotiated");
            Assert.IsTrue(
                !desc.IsCodeSetDefined(), "Codeset not user defined");
        }
Example #7
0
 /// <summary>
 /// constructor for the out-direction
 /// </summary>
 /// <param name="request">the request message, may be null</param>
 /// <param name="reply">the reply message</param>
 internal GiopServerRequest(IMessage request, ReturnMessage reply, GiopConnectionDesc conDesc,
                            IInterceptionOption[] interceptionOptions)
 {
     if (request is IMethodCallMessage)
     {
         m_requestCallMessage = (IMethodCallMessage)request;
     }
     m_requestMessage = request;
     m_replyMessage   = reply;
     m_conDesc        = conDesc;
     InitalizeForInterception(interceptionOptions);
 }
Example #8
0
        /// <summary>
        /// reads a locate-request message from the message input stream msgInput
        /// and formulates an answer.
        /// </summary>
        /// <returns></returns>
        internal Stream SerialiseOutgoingLocateReplyMessage(LocateReplyMessage replyMsg, LocateRequestMessage requestMsg,
                                                            GiopVersion version,
                                                            Stream targetStream, GiopConnectionDesc conDesc)
        {
            GiopHeader             header    = new GiopHeader(version.Major, version.Minor, m_headerFlags, GiopMsgTypes.LocateReply);
            CdrMessageOutputStream msgOutput = new CdrMessageOutputStream(targetStream, header);

            // serialize the message
            m_ser.SerialiseLocateReply(msgOutput.GetMessageContentWritingStream(), version,
                                       requestMsg.RequestId, replyMsg);
            msgOutput.CloseStream(); // write to the stream
            return(targetStream);
        }
Example #9
0
        public void TestLocateReplySerialisation()
        {
            uint requestId = 5;

            byte[]               objectKey = new byte[] { 116, 101, 115, 116, 111, 98, 106, 101, 99, 116 }; // testobject
            string               targetUri = "testobject";
            GiopVersion          version   = new GiopVersion(1, 2);
            LocateRequestMessage locReq    = new LocateRequestMessage(requestId, objectKey, targetUri);
            // create a connection context
            GiopConnectionDesc conDesc = new GiopConnectionDesc(null, null);

            // create the reply
            LocateStatus       replyStatus = LocateStatus.OBJECT_HERE;
            LocateReplyMessage locReply    = new LocateReplyMessage(replyStatus);

            MemoryStream targetStream = new MemoryStream();

            m_handler.SerialiseOutgoingLocateReplyMessage(locReply, locReq, version, targetStream, conDesc);

            // check to serialised stream
            targetStream.Seek(0, SeekOrigin.Begin);

            CdrInputStreamImpl cdrIn = new CdrInputStreamImpl(targetStream);

            cdrIn.ConfigStream(0, version);

            // first is Giop-magic
            byte data;

            AssertBytesFollowing(m_giopMagic, cdrIn);
            // Giop version
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(1, data);
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(2, data);
            // flags: big-endian, no fragements
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(0, data);
            // Giop Msg type: locate reply
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual((byte)GiopMsgTypes.LocateReply, data);
            // Giop Msg length
            uint msgLength = cdrIn.ReadULong();

            cdrIn.SetMaxLength(msgLength);
            // req-id
            Assert.AreEqual(requestId, cdrIn.ReadULong());
            // the location status
            Assert.AreEqual((uint)replyStatus, cdrIn.ReadULong());
        }
Example #10
0
        public void TestGiopConnectionDescSetCodeSet()
        {
            int charSet             = 0x5010001;
            int wcharSet            = 0x10100;
            GiopConnectionDesc desc =
                new GiopConnectionDesc(null, null);

            desc.SetNegotiatedCodeSets(charSet, wcharSet);
            Assert.IsTrue(
                desc.IsCodeSetNegotiated(), "Codeset negotiated");
            Assert.AreEqual(charSet, desc.CharSet, "char set");
            Assert.AreEqual(wcharSet, desc.WCharSet, "wchar set");
            Assert.IsTrue(desc.IsCodeSetDefined(), "Codeset user defined");
        }
Example #11
0
        public void TestLocateRequestDeserialisation()
        {
            MemoryStream sourceStream = new MemoryStream();
            // prepare msg
            uint                requestId = 5;
            GiopVersion         version   = new GiopVersion(1, 2);
            CdrOutputStreamImpl cdrOut    = new CdrOutputStreamImpl(sourceStream, 0,
                                                                    version);

            cdrOut.WriteOpaque(m_giopMagic);
            // version
            cdrOut.WriteOctet(version.Major);
            cdrOut.WriteOctet(version.Minor);
            // flags
            cdrOut.WriteOctet(0);
            // msg-type: request
            cdrOut.WriteOctet((byte)GiopMsgTypes.LocateRequest);
            // msg-length
            cdrOut.WriteULong(22);
            // request-id
            cdrOut.WriteULong(requestId);
            // target: key type
            cdrOut.WriteULong(0);
            cdrOut.WriteULong(10);                                                            // key length
            byte[] objectKey = new byte[] { 116, 101, 115, 116, 111, 98, 106, 101, 99, 116 }; // testobject
            cdrOut.WriteOpaque(objectKey);

            // create a connection context: this is needed for request deserialisation
            GiopConnectionDesc conDesc = new GiopConnectionDesc(null, null);

            // go to stream begin
            sourceStream.Seek(0, SeekOrigin.Begin);

            // deserialise request message
            LocateRequestMessage result = m_handler.ParseIncomingLocateRequestMessage(sourceStream);

            // now check if values are correct
            Assert.IsTrue(result != null, "deserialised message is null");
            Assert.AreEqual(requestId, result.RequestId);
            Assert.NotNull(result.ObjectKey);
            Assert.NotNull(result.TargetUri);
            Assert.AreEqual("testobject", result.TargetUri);
        }
Example #12
0
 /// <summary>serialises an outgoing .NET reply Message on server side</summary>
 internal void SerialiseOutgoingReplyMessage(IMessage replyMsg, IMessage requestMsg, GiopVersion version,
                                             Stream targetStream, GiopConnectionDesc conDesc)
 {
     if (replyMsg is ReturnMessage)
     {
         // write a CORBA response message into the stream targetStream
         GiopHeader             header    = new GiopHeader(version.Major, version.Minor, m_headerFlags, GiopMsgTypes.Reply);
         CdrMessageOutputStream msgOutput = new CdrMessageOutputStream(targetStream, header);
         GiopServerRequest      request   = new GiopServerRequest(requestMsg,
                                                                  (ReturnMessage)replyMsg, conDesc,
                                                                  m_interceptionOptions);
         // serialize the message
         m_ser.SerialiseReply(request, msgOutput.GetMessageContentWritingStream(),
                              version, conDesc);
         msgOutput.CloseStream(); // write to the stream
     }
     else
     {
         throw new NotImplementedException("handling for this type of .NET message is not implemented at the moment, type: " +
                                           replyMsg.GetType());
     }
 }
Example #13
0
        public void TestReplySerialisation()
        {
            // request msg the reply is for
            MethodInfo methodToCall = typeof(TestService).GetMethod("Add");

            object[]    args    = new object[] { ((Int32)1), ((Int32)2) };
            string      uri     = "iiop://localhost:8087/testuri"; // Giop 1.2 will be used because no version spec in uri
            GiopVersion version = new GiopVersion(1, 2);
            TestMessage msg     = new TestMessage(methodToCall, args, uri);

            msg.Properties[SimpleGiopMsg.REQUEST_ID_KEY]      = (uint)5;
            msg.Properties[SimpleGiopMsg.GIOP_VERSION_KEY]    = version;
            msg.Properties[SimpleGiopMsg.CALLED_METHOD_KEY]   = methodToCall;
            msg.Properties[SimpleGiopMsg.IDL_METHOD_NAME_KEY] = methodToCall.Name; // done by serialization normally
            // create a connection context
            GiopConnectionDesc conDesc = new GiopConnectionDesc(null, null);

            // create the reply
            ReturnMessage retMsg = new ReturnMessage((Int32)3, new object[0], 0, null, msg);

            MemoryStream targetStream = new MemoryStream();

            m_handler.SerialiseOutgoingReplyMessage(retMsg, msg, version,
                                                    targetStream, conDesc);

            // check to serialised stream
            targetStream.Seek(0, SeekOrigin.Begin);

            CdrInputStreamImpl cdrIn = new CdrInputStreamImpl(targetStream);

            cdrIn.ConfigStream(0, new GiopVersion(1, 2));

            // first is Giop-magic
            byte data;

            AssertBytesFollowing(m_giopMagic, cdrIn);
            // Giop version
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(1, data);
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(2, data);
            // flags: big-endian, no fragements
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(0, data);
            // Giop Msg type: reply
            data = (byte)cdrIn.ReadOctet();
            Assert.AreEqual(1, data);
            // Giop Msg length
            uint msgLength = cdrIn.ReadULong();

            cdrIn.SetMaxLength(msgLength);
            // req-id
            Assert.AreEqual(5, cdrIn.ReadULong());
            // response status: NO_EXCEPTION
            Assert.AreEqual(0, cdrIn.ReadULong());
            // ignore service contexts
            SkipServiceContexts(cdrIn);
            // Giop 1.2, must be aligned on 8
            cdrIn.ForceReadAlign(Aligns.Align8);
            // now return value is following
            Assert.AreEqual(3, cdrIn.ReadLong());
        }
Example #14
0
        public void TestRequestDeserialisation()
        {
            MemoryStream sourceStream = new MemoryStream();
            // prepare msg
            uint                requestId     = 5;
            byte                responseFlags = 3;
            string              methodName    = "Add";
            int                 nrOfArgs      = 2;
            int                 arg1          = 1;
            int                 arg2          = 2;
            GiopVersion         version       = new GiopVersion(1, 2);
            CdrOutputStreamImpl cdrOut        = new CdrOutputStreamImpl(sourceStream, 0,
                                                                        version);

            cdrOut.WriteOpaque(m_giopMagic);
            // version
            cdrOut.WriteOctet(version.Major);
            cdrOut.WriteOctet(version.Minor);
            // flags
            cdrOut.WriteOctet(0);
            // msg-type: request
            cdrOut.WriteOctet(0);
            // msg-length
            cdrOut.WriteULong(68);
            // request-id
            cdrOut.WriteULong(requestId);
            // response-flags
            cdrOut.WriteOctet(responseFlags);
            cdrOut.WritePadding(3);
            // target: key type
            cdrOut.WriteULong(0);
            cdrOut.WriteULong(10);                                                             // key length
            cdrOut.WriteOpaque(new byte[] { 116, 101, 115, 116, 111, 98, 106, 101, 99, 116 }); // testobject
            // method name
            cdrOut.WriteString(methodName);
            // no service contexts
            cdrOut.WriteULong(0);
            cdrOut.ForceWriteAlign(Aligns.Align8);
            // parameters
            cdrOut.WriteLong(arg1);
            cdrOut.WriteLong(arg2);

            // create a connection context: this is needed for request deserialisation
            GiopConnectionDesc conDesc = new GiopConnectionDesc(null, null);

            // go to stream begin
            sourceStream.Seek(0, SeekOrigin.Begin);

            IMessage    result  = null;
            TestService service = new TestService();

            try {
                // object which should be called
                string uri = "testobject";
                RemotingServices.Marshal(service, uri);

                // deserialise request message
                result = m_handler.ParseIncomingRequestMessage(sourceStream, conDesc);
            } catch (RequestDeserializationException e) {
                throw e;
            } finally {
                RemotingServices.Disconnect(service);
            }

            // now check if values are correct
            Assert.IsTrue(result != null, "deserialised message is null");
            Assert.AreEqual(requestId, result.Properties[SimpleGiopMsg.REQUEST_ID_KEY]);
            Assert.AreEqual(version, result.Properties[SimpleGiopMsg.GIOP_VERSION_KEY]);
            Assert.AreEqual(responseFlags, result.Properties[SimpleGiopMsg.RESPONSE_FLAGS_KEY]);
            Assert.AreEqual("testobject", result.Properties[SimpleGiopMsg.URI_KEY]);
            Assert.AreEqual("Ch.Elca.Iiop.Tests.TestService", result.Properties[SimpleGiopMsg.TYPENAME_KEY]);
            Assert.AreEqual(methodName, result.Properties[SimpleGiopMsg.METHODNAME_KEY]);
            object[] args = (object[])result.Properties[SimpleGiopMsg.ARGS_KEY];
            Assert.IsTrue(args != null, "args is null");
            Assert.AreEqual(nrOfArgs, args.Length);
            Assert.AreEqual(arg1, args[0]);
            Assert.AreEqual(arg2, args[1]);
        }
Example #15
0
 /// <summary>
 /// constructor for the out-direction
 /// </summary>
 /// <param name="request">the request message, may be null</param>
 /// <param name="reply">the reply message</param>
 internal GiopServerRequest(IMessage request, ReturnMessage reply, GiopConnectionDesc conDesc,
                            IInterceptionOption[] interceptionOptions) {
     if (request is IMethodCallMessage) {                
         m_requestCallMessage = (IMethodCallMessage)request;
     }
     m_requestMessage = request;
     m_replyMessage = reply;
     m_conDesc = conDesc;
     InitalizeForInterception(interceptionOptions);
 }
Example #16
0
 /// <summary>
 /// constructor for the in direction.
 /// </summary>
 internal GiopServerRequest(GiopConnectionDesc conDesc,
                            IInterceptionOption[] interceptionOptions) {
     m_requestMessage = new SimpleGiopMsg();
     m_requestCallMessage = null; // not yet created; will be created from requestMessage later.
     m_replyMessage = null; // not yet available
     m_conDesc = conDesc;
     InitalizeForInterception(interceptionOptions);
 }
 /// <summary>
 /// set the codesets for the stream after codeset service descision
 /// </summary>
 /// <param name="cdrStream"></param>
 private void SetCodeSet(CdrOutputStream cdrStream, GiopConnectionDesc conDesc) {
     if (conDesc.IsCodeSetDefined()) {
         // set the codeset, if one is chosen
         cdrStream.CharSet = conDesc.CharSet;
         cdrStream.WCharSet = conDesc.WCharSet;
     } // otherwise: use cdrStream default.
 }
 /// <summary>serialises an outgoing .NET reply Message on server side</summary>
 internal void SerialiseOutgoingReplyMessage(IMessage replyMsg, IMessage requestMsg, GiopVersion version,
                                             Stream targetStream, GiopConnectionDesc conDesc) {
     if (replyMsg is ReturnMessage) {
         // write a CORBA response message into the stream targetStream
         GiopHeader header = new GiopHeader(version.Major, version.Minor, m_headerFlags, GiopMsgTypes.Reply);
         CdrMessageOutputStream msgOutput = new CdrMessageOutputStream(targetStream, header);
         GiopServerRequest request = new GiopServerRequest(requestMsg,
                                                           (ReturnMessage)replyMsg, conDesc,
                                                           m_interceptionOptions);
         // serialize the message
         m_ser.SerialiseReply(request, msgOutput.GetMessageContentWritingStream(),
                              version, conDesc);
         msgOutput.CloseStream(); // write to the stream
     } else {
         throw new NotImplementedException("handling for this type of .NET message is not implemented at the moment, type: " +
                                           replyMsg.GetType());
     }
 }
        /// <summary>reads an incoming Giop request-message from the message input stream msgInput</summary>
        /// <returns>the .NET request message created from this Giop-message</returns>
        internal IMessage ParseIncomingRequestMessage(CdrMessageInputStream msgInput,
                                                    GiopConnectionDesc conDesc) {
 
            CdrInputStream msgBody = msgInput.GetMessageContentReadingStream();
            // deserialize the message body (the GIOP-request id is included in this message)
            return m_ser.DeserialiseRequest(msgBody, msgInput.Header.Version,
                                            conDesc, m_interceptionOptions);
        }
 /// <summary>reads an incoming Giop request-message from the Stream sourceStream</summary>
 /// <returns>the .NET request message created from this Giop-message</returns>
 internal IMessage ParseIncomingRequestMessage(Stream sourceStream,
                                             GiopConnectionDesc conDesc) {
     CdrMessageInputStream msgInput = new CdrMessageInputStream(sourceStream);
     return ParseIncomingRequestMessage(msgInput, conDesc);
 }
        internal IMessage DeserialiseReply(CdrInputStream cdrStream, 
                                         GiopVersion version, GiopClientRequest request,
                                         GiopConnectionDesc conDesc) {

            ServiceContextList cntxColl = null;
            IMessage response = null;
            try {
                if (version.IsBeforeGiop1_2()) { // for GIOP 1.0 / 1.1, the service context is placed here
                    cntxColl = DeserialiseContext(cdrStream); // deserialize the service contexts
                }
                
                cdrStream.ReadULong(); // skip request id, already handled by transport
                uint responseStatus = cdrStream.ReadULong();
                if (!version.IsBeforeGiop1_2()) { // for GIOP 1.2 and later, service context is here
                    cntxColl = DeserialiseContext(cdrStream); // deserialize the service contexts
                }
                // set codeset for stream
                SetCodeSet(cdrStream, conDesc);
                switch (responseStatus) {
                    case 0 :
                        Trace.WriteLine("deserializing normal reply for methodCall: " + request.MethodToCall);
                        response = DeserialiseNormalReply(cdrStream, version, request);
                        UpdateClientRequestWithReplyData(request, response, cntxColl);
                        request.InterceptReceiveReply();
                        break;
                    case 1 :
                        Exception userEx = DeserialiseUserException(cdrStream, version); // the error .NET message for this exception is created in the formatter
                        UpdateClientRequestWithReplyData(request, new ReturnMessage(userEx, request.Request), cntxColl);
                        userEx = request.InterceptReceiveException(userEx);
                        response = new ReturnMessage(userEx, request.Request); // definitive exception only available here, because interception chain may change exception
                        break;
                    case 2 :
                        Exception systemEx = DeserialiseSystemError(cdrStream, version); // the error .NET message for this exception is created in the formatter
                        UpdateClientRequestWithReplyData(request, new ReturnMessage(systemEx, request.Request), cntxColl);
                        systemEx = request.InterceptReceiveException(systemEx);
                        response = new ReturnMessage(systemEx, request.Request); // definitive exception only available here, because interception chain may change exception
                        break;
                    case 3 :
                    case 4 :
                        // LOCATION_FORWARD / LOCATION_FORWARD_PERM:
                        // --> deserialise it and return location fwd message
                        response = DeserialiseLocationFwdReply(cdrStream, version, request);
                        UpdateClientRequestWithReplyData(request, response, cntxColl);
                        request.InterceptReceiveOther();
                        break;
                        default :
                            // deseralization of reply error, unknown reply status: responseStatus
                            // the error .NET message for this exception is created in the formatter
                            throw new MARSHAL(2401, CompletionStatus.Completed_MayBe);
                }
            } catch (Exception ex) {
                Trace.WriteLine("exception while deserialising reply: " + ex);
                try {
                    cdrStream.SkipRest();
                } catch (Exception) {
                    // ignore this one, already problems.
                }
                if (!request.IsReplyInterceptionChainCompleted()) { // reply interception chain not yet called for this reply
                    // deserialisation not ok: interception not called;
                    // call interceptors with this exception.
                    request.Reply = new ReturnMessage(ex, request.Request as IMethodCallMessage);
                    Exception newException = request.InterceptReceiveException(ex); // exception may be changed by interception point
                    if (ex != newException) {
                        throw newException; // exception have been changed by interception point
                    }
                }
                throw;
            }
            return response;
        }
        /// <summary>
        /// perform code set establishment on the client side
        /// </summary>
        protected void PerformCodeSetEstablishmentClient(IIorProfile targetProfile,
                                                         GiopConnectionDesc conDesc,
                                                         ServiceContextList cntxColl) {
            
            if (targetProfile.Version.IsAfterGiop1_0()) {

                if (!conDesc.IsCodeSetNegotiated()) {
                    Codec codec =
                        m_codecFactory.create_codec(new Encoding(ENCODING_CDR_ENCAPS.ConstVal,
                                                                 targetProfile.Version.Major,
                                                                 targetProfile.Version.Minor));
                    object codeSetComponent = CodeSetService.FindCodeSetComponent(targetProfile, codec);
                    if (codeSetComponent != null) {
                        int charSet = CodeSetService.ChooseCharSet((CodeSetComponentData)codeSetComponent);
                        int wcharSet = CodeSetService.ChooseWCharSet((CodeSetComponentData)codeSetComponent);
                        conDesc.SetNegotiatedCodeSets(charSet, wcharSet);
                    } else {
                        conDesc.SetCodeSetNegotiated();
                    }
                    if (conDesc.IsCodeSetDefined()) {
                        // only insert a codeset service context, if a codeset is selected
                        CodeSetService.InsertCodeSetServiceContext(cntxColl,
                            conDesc.CharSet, conDesc.WCharSet);
                    }
                }
            } else {
                // giop 1.0; don't send code set service context; don't check again
                conDesc.SetCodeSetNegotiated();
            }
            
        }
        /// <summary>
        /// Deserialises the Giop Message body for a request
        /// </summary>
        /// <param name="cdrStream"></param>
        /// <param name="version"></param>
        /// <returns></returns>
        internal IMessage DeserialiseRequest(CdrInputStream cdrStream, GiopVersion version,
                                             GiopConnectionDesc conDesc, IInterceptionOption[] interceptionOptions) {
            MethodCall methodCallInfo = null;
            GiopServerRequest serverRequest = new GiopServerRequest(conDesc, interceptionOptions);
            serverRequest.Version = version;
            try {
                ServiceContextList cntxColl = null;
                if (version.IsBeforeGiop1_2()) { // GIOP 1.0 / 1.1
                    cntxColl = DeserialiseContext(cdrStream); // Service context deser
                }
                
                // read the request-ID and set it as a message property
                uint requestId = cdrStream.ReadULong(); 
                serverRequest.RequestId = requestId;
                Trace.WriteLine("received a message with reqId: " + requestId);
                // read response-flags:
                byte respFlags = cdrStream.ReadOctet(); Debug.WriteLine("response-flags: " + respFlags);
                cdrStream.ReadPadding(3); // read reserved bytes
                serverRequest.ResponseFlags = respFlags;
                
                // decode the target of this request
                byte[] objectKey;
                serverRequest.RequestUri = ReadTarget(cdrStream, version, out objectKey);
                serverRequest.ObjectKey = objectKey;
                serverRequest.RequestMethodName = cdrStream.ReadString();
                Trace.WriteLine("call for .NET object: " + serverRequest.RequestUri + 
                                ", methodName: " + serverRequest.RequestMethodName);

                if (version.IsBeforeGiop1_2()) { // GIOP 1.0 / 1.1
                    uint principalLength = cdrStream.ReadULong();
                    cdrStream.ReadOpaque((int)principalLength);
                } else {
                    cntxColl = DeserialiseContext(cdrStream); // Service context deser
                }
                PerformCodeSetEstablishmentServer(version, conDesc, cntxColl);
                // set codeset for stream
                SetCodeSet(cdrStream, conDesc);
                // request header deserialised

                serverRequest.RequestServiceContext = cntxColl;
                serverRequest.InterceptReceiveRequestServiceContexts();
                serverRequest.SetThreadScopeCurrentFromPICurrent(); // copy request scope picurrent to thread scope pi-current
                
                serverRequest.ResolveTargetType(); // determine the .net target object type and check if target object is available
                ArgumentsSerializer argSer =
                    m_argSerFactory.Create(serverRequest.ServerTypeType);
                MethodInfo called =
                    argSer.GetMethodInfoFor(serverRequest.RequestMethodName);
                serverRequest.ResolveCalledMethod(called); // set target method and handle special cases
                IDictionary contextElements;
                DeserialiseRequestBody(cdrStream, version, serverRequest, argSer, out contextElements);
                methodCallInfo = new MethodCall(serverRequest.Request);
                if (contextElements != null) {
                    AddContextElementsToCallContext(methodCallInfo.LogicalCallContext, contextElements);
                }
                serverRequest.UpdateWithFinalRequest(methodCallInfo);
                serverRequest.InterceptReceiveRequest(); // all information now available
                return methodCallInfo;
            } catch (Exception e) {
                // an Exception encountered during deserialisation
                try {
                    cdrStream.SkipRest(); // skip rest of the message, to not corrupt the stream
                } catch (Exception) {
                    // ignore exception here, already an other exception leading to problems
                }
                ReturnMessage exceptionResponse;
                exceptionResponse = new ReturnMessage(e, methodCallInfo);
                throw new RequestDeserializationException(e, serverRequest.Request, exceptionResponse);
                // send exception interception point will be called when serialising exception response
            }
        }
 /// <summary>
 /// serialises the message body for a GIOP request
 /// </summary>
 /// <param name="clientRequest">the giop request Msg</param>
 /// <param name="targetStream"></param>
 /// <param name="version">the Giop version to use</param>
 /// <param name="conDesc">the connection used for this request</param>
 internal void SerialiseRequest(GiopClientRequest clientRequest,
                                CdrOutputStream targetStream, 
                                IIorProfile targetProfile, GiopConnectionDesc conDesc) {
     Trace.WriteLine(String.Format("serializing request for method {0}; uri {1}; id {2}", 
                                   clientRequest.MethodToCall, clientRequest.CalledUri, 
                                   clientRequest.RequestId));
     try {
         clientRequest.SetRequestPICurrentFromThreadScopeCurrent(); // copy from thread scope picurrent before processing request
         
         ArgumentsSerializer ser =
             m_argSerFactory.Create(clientRequest.MethodToCall.DeclaringType);
         // determine the request method to send
         string idlRequestName = ser.GetRequestNameFor(clientRequest.MethodToCall);
         clientRequest.RequestMethodName = idlRequestName;
         
         clientRequest.InterceptSendRequest();
         GiopVersion version = targetProfile.Version;
         ServiceContextList cntxColl = clientRequest.RequestServiceContext;
         // set code-set for the stream
         PerformCodeSetEstablishmentClient(targetProfile, conDesc, cntxColl);
         SetCodeSet(targetStream, conDesc);
         
         if (version.IsBeforeGiop1_2()) { // for GIOP 1.0 / 1.1
             SerialiseContext(targetStream, cntxColl); // service context
         }
         
         targetStream.WriteULong(clientRequest.RequestId);
         byte responseFlags = 0;
         if (version.IsBeforeGiop1_2()) { // GIOP 1.0 / 1.1
             responseFlags = 1;
         } else {
             // reply-expected, no DII-call --> must be 0x03, no reply --> must be 0x00
             responseFlags = 3;
         }
         if (clientRequest.IsOneWayCall) {
             responseFlags = 0;
         } // check if one-way
         // write response-flags
         targetStream.WriteOctet(responseFlags);
         
         targetStream.WritePadding(3); // reserved bytes
         WriteTarget(targetStream, targetProfile.ObjectKey, version); // write the target-info
         targetStream.WriteString(clientRequest.RequestMethodName); // write the method name
         
         if (version.IsBeforeGiop1_2()) { // GIOP 1.0 / 1.1
             targetStream.WriteULong(0); // no principal
         } else { // GIOP 1.2
             SerialiseContext(targetStream, cntxColl); // service context
         }
         SerialiseRequestBody(targetStream, clientRequest, version, ser);
     } catch (Exception ex) {
         Debug.WriteLine("exception while serialising request: " + ex);
         Exception newException = clientRequest.InterceptReceiveException(ex); // interception point may change exception
         if (newException == ex) {
             throw;
         } else {
             throw newException; // exception has been changed by interception point
         }
     }
 }
 /// <summary>
 /// reads a locate-request message from the message input stream msgInput
 /// and formulates an answer.
 /// </summary>
 /// <returns></returns>
 internal Stream SerialiseOutgoingLocateReplyMessage(LocateReplyMessage replyMsg, LocateRequestMessage requestMsg,
                                                     GiopVersion version,
                                                     Stream targetStream, GiopConnectionDesc conDesc) {
     GiopHeader header = new GiopHeader(version.Major, version.Minor, m_headerFlags, GiopMsgTypes.LocateReply);
     CdrMessageOutputStream msgOutput = new CdrMessageOutputStream(targetStream, header);
     // serialize the message
     m_ser.SerialiseLocateReply(msgOutput.GetMessageContentWritingStream(), version,
                                requestMsg.RequestId, replyMsg);
     msgOutput.CloseStream(); // write to the stream
     return targetStream;
 }
 /// <summary>serialize the GIOP message body of a repsonse message</summary>
 /// <param name="requestId">the requestId of the request, this response belongs to</param>
 internal void SerialiseReply(GiopServerRequest request, CdrOutputStream targetStream, 
                            GiopVersion version,
                            GiopConnectionDesc conDesc) {
     Trace.WriteLine("serializing response for method: " + request.GetRequestedMethodNameInternal());
     try {
         bool isExceptionReply = request.IsExceptionReply;
         Exception exceptionToSend = null;
         try {
             request.SetRequestPICurrentFromThreadScopeCurrent(); // copy from thread scope picurrent after processing request by servant
             // reply interception point
             if (!request.IsExceptionReply) {
                 request.InterceptSendReply();
             } else {
                 exceptionToSend = request.InterceptSendException(request.IdlException);
             }
         } catch (Exception ex) {
             // update the reply with the exception from interception layer
             isExceptionReply = true;
             if (SerialiseAsSystemException(ex)) {
                 exceptionToSend = ex;
             } else {
                 exceptionToSend = new UNKNOWN(300, CompletionStatus.Completed_MayBe);
             }
         }
         ServiceContextList cntxColl = request.ResponseServiceContext;
         SetCodeSet(targetStream, conDesc);
         
         if (version.IsBeforeGiop1_2()) { // for GIOP 1.0 / 1.1
             SerialiseContext(targetStream, cntxColl); // serialize the context
         }
         
         targetStream.WriteULong(request.RequestId);
         
         if (!isExceptionReply) {
             Trace.WriteLine("sending normal response to client");
             targetStream.WriteULong(0); // reply status ok
             
             if (!version.IsBeforeGiop1_2()) { // for GIOP 1.2 and later, service context is here
                 SerialiseContext(targetStream, cntxColl); // serialize the context
             }
             // serialize a response to a successful request
             SerialiseResponseOk(targetStream, request, version);
             Trace.WriteLine("reply body serialised");
         } else {
             Trace.WriteLine("excpetion to send to client: " + exceptionToSend.GetType());
             
             if (SerialiseAsSystemException(exceptionToSend)) {
                 targetStream.WriteULong(2); // system exception
             } else if (SerialiseAsUserException(exceptionToSend)) {
                 targetStream.WriteULong(1); // user exception
             } else {
                 // should not occur
                 targetStream.WriteULong(2);
                 exceptionToSend = new INTERNAL(204, CompletionStatus.Completed_Yes);
             }
             
             if (!version.IsBeforeGiop1_2()) { // for GIOP 1.2 and later, service context is here
                 SerialiseContext(targetStream, cntxColl); // serialize the context
             }
             AlignBodyIfNeeded(targetStream, version);
             if (SerialiseAsSystemException(exceptionToSend)) {
                 SerialiseSystemException(targetStream, exceptionToSend);
             } else {
                 SerialiseUserException(targetStream, (AbstractUserException)exceptionToSend);
             }
             Trace.WriteLine("exception reply serialised");
         }
     } finally {
         request.ClearThreadScopePICurrent(); // no longer needed, clear afterwards to prevent access to stale data during next requests
     }
 }
 /// <summary>
 /// perform code set establishment on the server side
 /// </summary>
 protected void PerformCodeSetEstablishmentServer(GiopVersion version,
                                                  GiopConnectionDesc conDesc, 
                                                  ServiceContextList cntxColl) {
     if (version.IsAfterGiop1_0()) {
         if (!conDesc.IsCodeSetNegotiated()) {
             // check for code set establishment
             CodeSetServiceContext context = 
                 CodeSetService.FindCodeSetServiceContext(cntxColl);
             if (context != null) {
                 CodeSetService.CheckCodeSetCompatible(context.CharSet,
                                                       context.WCharSet);
                 conDesc.SetNegotiatedCodeSets(context.CharSet,
                                               context.WCharSet);
             }
         }
     } else {
         conDesc.SetCodeSetNegotiated();
     }
 }