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;
}
/// <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>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());
}
}
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);
}
