private uint AddFinishFragment(CdrOutputStreamImpl targetStream, GiopVersion version, byte endianFlags, uint reqId, uint reqContentLength, uint offsetInMsg) { byte giopFlags = endianFlags; // no more fragments GiopHeader fragmentHeader = new GiopHeader(version.Major, version.Minor, endianFlags, GiopMsgTypes.Request); uint contentLength = 0; if (!((version.Major == 1) && (version.Minor <= 1))) { // GIOP 1.2 contentLength = 4 + reqContentLength; } else { contentLength = reqContentLength; } fragmentHeader.WriteToStream(targetStream, contentLength); if (!((version.Major == 1) && (version.Minor <= 1))) { // GIOP 1.2 targetStream.WriteULong(reqId); } // more is not needed to write a correct GIOP-message for this test from here for (uint i = offsetInMsg; i < (offsetInMsg + reqContentLength); i++) { targetStream.WriteOctet((byte)(i % 255)); } return(offsetInMsg + reqContentLength); }
/// <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); }
public void TestGetHeaderFlagsForPlatform() { byte expected; if (BitConverter.IsLittleEndian) { expected = 1; } else { expected = 0; } Assert.AreEqual(expected, GiopHeader.GetDefaultHeaderFlagsForPlatform()); }
public void SetUp() { m_serFactory = new SerializerFactory(); omg.org.IOP.CodecFactory codecFactory = new Ch.Elca.Iiop.Interception.CodecFactoryImpl(m_serFactory); m_codec = codecFactory.create_codec( new omg.org.IOP.Encoding(omg.org.IOP.ENCODING_CDR_ENCAPS.ConstVal, 1, 2)); m_iiopUrlUtil = IiopUrlUtil.Create(m_codec, new object[] { Services.CodeSetService.CreateDefaultCodesetComponent(m_codec) }); m_serFactory.Initalize(new SerializerFactoryConfig(), m_iiopUrlUtil); m_handler = new GiopMessageHandler( new ArgumentsSerializerFactory(m_serFactory), GiopHeader.GetDefaultHeaderFlagsForEndian(Endian.BigEndian)); }
/// <param name="fragmentContentBlocks">the nr of 4 byte blocks in the content; /// must be even for GIOP 1.2</param> private CdrOutputStreamImpl AddStartMsg(Stream targetStream, GiopVersion version, byte endianFlags, uint reqId, uint fragmentContentBlocks, out uint offsetInMsg) { byte giopFlags = (byte)(endianFlags | ((byte)2)); // more fragments CdrOutputStreamImpl cdrOut = new CdrOutputStreamImpl(targetStream, endianFlags, version); GiopHeader startHeader = new GiopHeader(version.Major, version.Minor, giopFlags, GiopMsgTypes.Request); uint contentLength = 0; if (!((version.Major == 1) && (version.Minor <= 1))) { // GIOP 1.2 contentLength = (uint)(4 + (fragmentContentBlocks * 4)); } else { contentLength = (uint)(8 + (fragmentContentBlocks * 4)); } startHeader.WriteToStream(cdrOut, contentLength); if ((version.Major == 1) && (version.Minor == 1)) { // GIOP 1.1: add service context list here cdrOut.WriteULong(0); // no contexts } cdrOut.WriteULong(reqId); // request id // more is not needed to write a correct GIOP-message for this test from here for (uint i = 0; i < fragmentContentBlocks * 4; i++) { cdrOut.WriteOctet((byte)(i % 255)); } offsetInMsg = fragmentContentBlocks * 4; return(cdrOut); }
/// <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()); } }
/// <param name="expectedContentLength">length in bytes after the request-id</param> private void CheckAssembledMessage(Stream msgStream, GiopVersion version, byte endianFlags, uint reqId, uint expectedContentLength) { CdrInputStreamImpl inStream = new CdrInputStreamImpl(msgStream); GiopHeader header = new GiopHeader(inStream); Assert.AreEqual(GiopMsgTypes.Request, header.GiopType); Assert.AreEqual(version, header.Version); uint contentLength = 0; uint msgReqId = 0; if (!((version.Major == 1) && (version.Minor <= 1))) { // GIOP 1.2 // req-id contentLength = (uint)(4 + expectedContentLength); msgReqId = inStream.ReadULong(); } else { // svc-cntx + req-id contentLength = (uint)(8 + expectedContentLength); inStream.ReadULong(); // svc-cnxt msgReqId = inStream.ReadULong(); } Assert.AreEqual(contentLength, header.ContentMsgLength); Assert.AreEqual(endianFlags, header.GiopFlags); for (int i = 0; i < expectedContentLength; i++) { Assert.AreEqual(i % 255, inStream.ReadOctet()); } }
/// <summary>serialises an outgoing .NET request Message on client side</summary> internal void SerialiseOutgoingRequestMessage(IMessage msg, IIorProfile target, GiopClientConnectionDesc conDesc, Stream targetStream, uint requestId) { if (msg is IConstructionCallMessage) { // not supported in CORBA, TBD: replace through do nothing instead of exception throw new NotSupportedException("client activated objects are not supported with this channel"); } else if (msg is IMethodCallMessage) { GiopVersion version = target.Version; // write a CORBA request message into the stream targetStream GiopHeader header = new GiopHeader(version.Major, version.Minor, m_headerFlags, GiopMsgTypes.Request); CdrMessageOutputStream msgOutput = new CdrMessageOutputStream(targetStream, header); // serialize the message, this insert some data into msg, e.g. request-id msg.Properties[SimpleGiopMsg.REQUEST_ID_KEY] = requestId; // set request-id msg.Properties[SimpleGiopMsg.TARGET_PROFILE_KEY] = target; GiopClientRequest request = new GiopClientRequest((IMethodCallMessage)msg, conDesc, m_interceptionOptions); m_ser.SerialiseRequest(request, msgOutput.GetMessageContentWritingStream(), target, conDesc); msgOutput.CloseStream(); if ((request.IsAsyncRequest) || (request.IsOneWayCall)) { // after successful serialisation, call for oneway and async requests receive other, // see corba 2.6, page 21-12. request.InterceptReceiveOther(); } } else { throw new NotImplementedException("handling for this type of .NET message is not implemented at the moment, type: " + msg.GetType()); } }
public void TestGetHeaderFlagsForLittleEndian() { Assert.AreEqual(1, GiopHeader.GetDefaultHeaderFlagsForEndian(Endian.LittleEndian)); }
public void TestGetHeaderFlagsForBigEndian() { Assert.AreEqual(0, GiopHeader.GetDefaultHeaderFlagsForEndian(Endian.BigEndian)); }
/// <summary> /// create an IOP service context from the code set service context /// </summary> /// <returns></returns> public omg.org.IOP.ServiceContext CreateServiceContext() { CdrEncapsulationOutputStream encapStream = new CdrEncapsulationOutputStream(GiopHeader.GetDefaultHeaderFlagsForPlatform()); encapStream.WriteULong((uint)m_charSet); encapStream.WriteULong((uint)m_wcharSet); return(new omg.org.IOP.ServiceContext(CodeSetService.SERVICE_ID, encapStream.GetEncapsulationData())); }
/// <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; }
private CdrEncapsulationOutputStream GetProfileContentStream() { CdrEncapsulationOutputStream encapStream = new CdrEncapsulationOutputStream(GiopHeader.GetDefaultHeaderFlagsForPlatform()); // the tagged components m_taggedComponents.WriteTaggedComponentList(encapStream); return(encapStream); }
private CdrEncapsulationOutputStream GetProfileContentStream() { CdrEncapsulationOutputStream encapStream = new CdrEncapsulationOutputStream(GiopHeader.GetDefaultHeaderFlagsForPlatform()); encapStream.WriteOctet(m_giopVersion.Major); encapStream.WriteOctet(m_giopVersion.Minor); encapStream.WriteString(m_hostName); encapStream.WriteUShort(m_port); encapStream.WriteULong((uint)m_objectKey.Length); encapStream.WriteOpaque(m_objectKey); // the tagged components if (!(m_giopVersion.Major == 1 && m_giopVersion.Minor == 0)) { // for GIOP >= 1.1, tagged components are possible m_taggedComponents.WriteTaggedComponentList(encapStream); } return(encapStream); }