1845 lines
65 KiB
C#
1845 lines
65 KiB
C#
//----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.Serialization;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Security;
|
|
using System.Xml;
|
|
|
|
sealed class WsrmMessageInfo
|
|
{
|
|
WsrmAcknowledgmentInfo acknowledgementInfo;
|
|
WsrmAckRequestedInfo ackRequestedInfo;
|
|
string action;
|
|
CloseSequenceInfo closeSequenceInfo;
|
|
CloseSequenceResponseInfo closeSequenceResponseInfo;
|
|
CreateSequenceInfo createSequenceInfo;
|
|
CreateSequenceResponseInfo createSequenceResponseInfo;
|
|
Exception faultException;
|
|
MessageFault faultInfo;
|
|
Message faultReply;
|
|
Message message;
|
|
Exception parsingException;
|
|
WsrmSequencedMessageInfo sequencedMessageInfo;
|
|
TerminateSequenceInfo terminateSequenceInfo;
|
|
TerminateSequenceResponseInfo terminateSequenceResponseInfo;
|
|
WsrmUsesSequenceSSLInfo usesSequenceSSLInfo;
|
|
WsrmUsesSequenceSTRInfo usesSequenceSTRInfo;
|
|
|
|
public WsrmMessageInfo()
|
|
{
|
|
}
|
|
|
|
public WsrmAcknowledgmentInfo AcknowledgementInfo
|
|
{
|
|
get
|
|
{
|
|
return acknowledgementInfo;
|
|
}
|
|
}
|
|
|
|
public WsrmAckRequestedInfo AckRequestedInfo
|
|
{
|
|
get
|
|
{
|
|
return this.ackRequestedInfo;
|
|
}
|
|
}
|
|
|
|
public string Action
|
|
{
|
|
get
|
|
{
|
|
return this.action;
|
|
}
|
|
}
|
|
|
|
public CloseSequenceInfo CloseSequenceInfo
|
|
{
|
|
get
|
|
{
|
|
return this.closeSequenceInfo;
|
|
}
|
|
}
|
|
|
|
public CloseSequenceResponseInfo CloseSequenceResponseInfo
|
|
{
|
|
get
|
|
{
|
|
return this.closeSequenceResponseInfo;
|
|
}
|
|
}
|
|
|
|
public CreateSequenceInfo CreateSequenceInfo
|
|
{
|
|
get
|
|
{
|
|
return this.createSequenceInfo;
|
|
}
|
|
}
|
|
|
|
public CreateSequenceResponseInfo CreateSequenceResponseInfo
|
|
{
|
|
get
|
|
{
|
|
return this.createSequenceResponseInfo;
|
|
}
|
|
}
|
|
|
|
public Exception FaultException
|
|
{
|
|
get
|
|
{
|
|
return this.faultException;
|
|
}
|
|
set
|
|
{
|
|
if (this.faultException != null)
|
|
{
|
|
throw Fx.AssertAndThrow("FaultException can only be set once.");
|
|
}
|
|
|
|
this.faultException = value;
|
|
}
|
|
}
|
|
|
|
public MessageFault FaultInfo
|
|
{
|
|
get
|
|
{
|
|
return this.faultInfo;
|
|
}
|
|
}
|
|
|
|
public Message FaultReply
|
|
{
|
|
get
|
|
{
|
|
return this.faultReply;
|
|
}
|
|
set
|
|
{
|
|
if (this.faultReply != null)
|
|
{
|
|
throw Fx.AssertAndThrow("FaultReply can only be set once.");
|
|
}
|
|
|
|
this.faultReply = value;
|
|
}
|
|
}
|
|
|
|
public Message Message
|
|
{
|
|
get
|
|
{
|
|
return this.message;
|
|
}
|
|
}
|
|
|
|
public MessageFault MessageFault
|
|
{
|
|
get
|
|
{
|
|
return this.faultInfo;
|
|
}
|
|
}
|
|
|
|
public Exception ParsingException
|
|
{
|
|
get
|
|
{
|
|
return this.parsingException;
|
|
}
|
|
}
|
|
|
|
public WsrmSequencedMessageInfo SequencedMessageInfo
|
|
{
|
|
get
|
|
{
|
|
return sequencedMessageInfo;
|
|
}
|
|
}
|
|
|
|
public TerminateSequenceInfo TerminateSequenceInfo
|
|
{
|
|
get
|
|
{
|
|
return terminateSequenceInfo;
|
|
}
|
|
}
|
|
|
|
public TerminateSequenceResponseInfo TerminateSequenceResponseInfo
|
|
{
|
|
get
|
|
{
|
|
return terminateSequenceResponseInfo;
|
|
}
|
|
}
|
|
|
|
public WsrmUsesSequenceSSLInfo UsesSequenceSSLInfo
|
|
{
|
|
get
|
|
{
|
|
return usesSequenceSSLInfo;
|
|
}
|
|
}
|
|
|
|
public WsrmUsesSequenceSTRInfo UsesSequenceSTRInfo
|
|
{
|
|
get
|
|
{
|
|
return usesSequenceSTRInfo;
|
|
}
|
|
}
|
|
|
|
public WsrmHeaderFault WsrmHeaderFault
|
|
{
|
|
get
|
|
{
|
|
return this.faultInfo as WsrmHeaderFault;
|
|
}
|
|
}
|
|
|
|
public static Exception CreateInternalFaultException(Message faultReply, string message, Exception inner)
|
|
{
|
|
return new InternalFaultException(faultReply, SR.GetString(SR.WsrmMessageProcessingError, message), inner);
|
|
}
|
|
|
|
static Exception CreateWsrmRequiredException(MessageVersion messageVersion)
|
|
{
|
|
string exceptionReason = SR.GetString(SR.WsrmRequiredExceptionString);
|
|
string faultReason = SR.GetString(SR.WsrmRequiredFaultString);
|
|
Message faultReply = new WsrmRequiredFault(faultReason).CreateMessage(messageVersion,
|
|
ReliableMessagingVersion.WSReliableMessaging11);
|
|
return CreateInternalFaultException(faultReply, exceptionReason, new ProtocolException(exceptionReason));
|
|
}
|
|
|
|
// Caller should check these things:
|
|
// FaultReply and FaultException, FaultInfo and FaultException or ParsingException
|
|
public static WsrmMessageInfo Get(MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion, IChannel channel, ISession session, Message message)
|
|
{
|
|
return Get(messageVersion, reliableMessagingVersion, channel, session, message, false);
|
|
}
|
|
|
|
public static WsrmMessageInfo Get(MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion, IChannel channel, ISession session, Message message,
|
|
bool csrOnly)
|
|
{
|
|
WsrmMessageInfo messageInfo = new WsrmMessageInfo();
|
|
messageInfo.message = message;
|
|
bool isFault = true;
|
|
|
|
try
|
|
{
|
|
isFault = message.IsFault;
|
|
MessageHeaders headers = message.Headers;
|
|
string action = headers.Action;
|
|
messageInfo.action = action;
|
|
bool foundAction = false;
|
|
bool wsrmFeb2005 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
|
|
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
|
|
bool csOnly = false;
|
|
|
|
if (action == WsrmIndex.GetCreateSequenceResponseActionString(reliableMessagingVersion))
|
|
{
|
|
messageInfo.createSequenceResponseInfo = CreateSequenceResponseInfo.ReadMessage(messageVersion,
|
|
reliableMessagingVersion, message, headers);
|
|
ValidateMustUnderstand(messageVersion, message);
|
|
return messageInfo;
|
|
}
|
|
|
|
if (csrOnly)
|
|
return messageInfo;
|
|
|
|
if (action == WsrmIndex.GetTerminateSequenceActionString(reliableMessagingVersion))
|
|
{
|
|
messageInfo.terminateSequenceInfo = TerminateSequenceInfo.ReadMessage(messageVersion,
|
|
reliableMessagingVersion, message, headers);
|
|
foundAction = true;
|
|
}
|
|
else if (action == WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion))
|
|
{
|
|
messageInfo.createSequenceInfo = CreateSequenceInfo.ReadMessage(messageVersion,
|
|
reliableMessagingVersion, session as ISecureConversationSession, message, headers);
|
|
|
|
if (wsrmFeb2005)
|
|
{
|
|
ValidateMustUnderstand(messageVersion, message);
|
|
return messageInfo;
|
|
}
|
|
|
|
csOnly = true;
|
|
}
|
|
else if (wsrm11)
|
|
{
|
|
if (action == Wsrm11Strings.CloseSequenceAction)
|
|
{
|
|
messageInfo.closeSequenceInfo = CloseSequenceInfo.ReadMessage(messageVersion, message,
|
|
headers);
|
|
foundAction = true;
|
|
}
|
|
else if (action == Wsrm11Strings.CloseSequenceResponseAction)
|
|
{
|
|
messageInfo.closeSequenceResponseInfo = CloseSequenceResponseInfo.ReadMessage(messageVersion,
|
|
message, headers);
|
|
foundAction = true;
|
|
}
|
|
else if (action == WsrmIndex.GetTerminateSequenceResponseActionString(reliableMessagingVersion))
|
|
{
|
|
messageInfo.terminateSequenceResponseInfo = TerminateSequenceResponseInfo.ReadMessage(messageVersion,
|
|
message, headers);
|
|
foundAction = true;
|
|
}
|
|
}
|
|
|
|
string wsrmNs = WsrmIndex.GetNamespaceString(reliableMessagingVersion);
|
|
bool soap11 = messageVersion.Envelope == EnvelopeVersion.Soap11;
|
|
bool foundHeader = false;
|
|
int foundTooManyIndex = -1;
|
|
int sequenceIndex = -1;
|
|
int ackIndex = -1;
|
|
int ackRequestedIndex = -1;
|
|
int maxIndex = -1;
|
|
int minIndex = -1;
|
|
int sequenceFaultIndex = -1;
|
|
int usesSequenceSSLIndex = -1;
|
|
int usesSequenceSTRIndex = -1;
|
|
|
|
for (int index = 0; index < headers.Count; index++)
|
|
{
|
|
MessageHeaderInfo header = headers[index];
|
|
|
|
if (!messageVersion.Envelope.IsUltimateDestinationActor(header.Actor))
|
|
continue;
|
|
|
|
if (header.Namespace == wsrmNs)
|
|
{
|
|
bool setIndex = true;
|
|
|
|
if (csOnly)
|
|
{
|
|
if (wsrm11 && (header.Name == Wsrm11Strings.UsesSequenceSSL))
|
|
{
|
|
if (usesSequenceSSLIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
usesSequenceSSLIndex = index;
|
|
}
|
|
else if (wsrm11 && (header.Name == Wsrm11Strings.UsesSequenceSTR))
|
|
{
|
|
if (usesSequenceSTRIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
usesSequenceSTRIndex = index;
|
|
}
|
|
else
|
|
{
|
|
setIndex = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (header.Name == WsrmFeb2005Strings.Sequence)
|
|
{
|
|
if (sequenceIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
sequenceIndex = index;
|
|
}
|
|
else if (header.Name == WsrmFeb2005Strings.SequenceAcknowledgement)
|
|
{
|
|
if (ackIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
ackIndex = index;
|
|
}
|
|
else if (header.Name == WsrmFeb2005Strings.AckRequested)
|
|
{
|
|
if (ackRequestedIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
ackRequestedIndex = index;
|
|
}
|
|
else if (soap11 && (header.Name == WsrmFeb2005Strings.SequenceFault))
|
|
{
|
|
if (sequenceFaultIndex != -1)
|
|
{
|
|
foundTooManyIndex = index;
|
|
break;
|
|
}
|
|
sequenceFaultIndex = index;
|
|
}
|
|
else
|
|
{
|
|
setIndex = false;
|
|
}
|
|
}
|
|
|
|
if (setIndex)
|
|
{
|
|
if (index > maxIndex)
|
|
maxIndex = index;
|
|
|
|
if (minIndex == -1)
|
|
minIndex = index;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (foundTooManyIndex != -1)
|
|
{
|
|
Collection<MessageHeaderInfo> notUnderstoodHeaders = new Collection<MessageHeaderInfo>();
|
|
notUnderstoodHeaders.Add(headers[foundTooManyIndex]);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MustUnderstandSoapException(notUnderstoodHeaders, messageVersion.Envelope));
|
|
}
|
|
|
|
if (maxIndex > -1)
|
|
{
|
|
BufferedMessage bufferedMessage = message as BufferedMessage;
|
|
|
|
if (bufferedMessage != null && bufferedMessage.Headers.ContainsOnlyBufferedMessageHeaders)
|
|
{
|
|
foundHeader = true;
|
|
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(minIndex))
|
|
{
|
|
for (int index = minIndex; index <= maxIndex; index++)
|
|
{
|
|
MessageHeaderInfo header = headers[index];
|
|
|
|
if (csOnly)
|
|
{
|
|
if (wsrm11 && (index == usesSequenceSSLIndex))
|
|
{
|
|
messageInfo.usesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(
|
|
reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
else if (wsrm11 && (index == usesSequenceSTRIndex))
|
|
{
|
|
messageInfo.usesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(
|
|
reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
else
|
|
{
|
|
reader.Skip();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (index == sequenceIndex)
|
|
{
|
|
messageInfo.sequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(
|
|
reliableMessagingVersion, reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
else if (index == ackIndex)
|
|
{
|
|
messageInfo.acknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(
|
|
reliableMessagingVersion, reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
else if (index == ackRequestedIndex)
|
|
{
|
|
messageInfo.ackRequestedInfo = WsrmAckRequestedInfo.ReadHeader(
|
|
reliableMessagingVersion, reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
else
|
|
{
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (maxIndex > -1 && !foundHeader)
|
|
{
|
|
foundHeader = true;
|
|
|
|
if (csOnly)
|
|
{
|
|
if (usesSequenceSSLIndex != -1)
|
|
{
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(usesSequenceSSLIndex))
|
|
{
|
|
MessageHeaderInfo header = headers[usesSequenceSSLIndex];
|
|
messageInfo.usesSequenceSSLInfo = WsrmUsesSequenceSSLInfo.ReadHeader(
|
|
reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
}
|
|
|
|
if (usesSequenceSTRIndex != -1)
|
|
{
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(usesSequenceSTRIndex))
|
|
{
|
|
MessageHeaderInfo header = headers[usesSequenceSTRIndex];
|
|
messageInfo.usesSequenceSTRInfo = WsrmUsesSequenceSTRInfo.ReadHeader(
|
|
reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (sequenceIndex != -1)
|
|
{
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(sequenceIndex))
|
|
{
|
|
MessageHeaderInfo header = headers[sequenceIndex];
|
|
|
|
messageInfo.sequencedMessageInfo = WsrmSequencedMessageInfo.ReadHeader(
|
|
reliableMessagingVersion, reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
}
|
|
|
|
if (ackIndex != -1)
|
|
{
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(ackIndex))
|
|
{
|
|
MessageHeaderInfo header = headers[ackIndex];
|
|
messageInfo.acknowledgementInfo = WsrmAcknowledgmentInfo.ReadHeader(
|
|
reliableMessagingVersion, reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
}
|
|
|
|
if (ackRequestedIndex != -1)
|
|
{
|
|
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(ackRequestedIndex))
|
|
{
|
|
MessageHeaderInfo header = headers[ackRequestedIndex];
|
|
messageInfo.ackRequestedInfo = WsrmAckRequestedInfo.ReadHeader(reliableMessagingVersion,
|
|
reader, header);
|
|
headers.UnderstoodHeaders.Add(header);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (csOnly)
|
|
{
|
|
CreateSequenceInfo.ValidateCreateSequenceHeaders(messageVersion,
|
|
session as ISecureConversationSession, messageInfo);
|
|
ValidateMustUnderstand(messageVersion, message);
|
|
return messageInfo;
|
|
}
|
|
|
|
if (messageInfo.sequencedMessageInfo == null && messageInfo.action == null)
|
|
{
|
|
if (wsrmFeb2005)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(SR.GetString(SR.NoActionNoSequenceHeaderReason), messageVersion.Addressing.Namespace, AddressingStrings.Action, false));
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
CreateWsrmRequiredException(messageVersion));
|
|
}
|
|
}
|
|
|
|
if (messageInfo.sequencedMessageInfo == null && message.IsFault)
|
|
{
|
|
messageInfo.faultInfo = MessageFault.CreateFault(message, TransportDefaults.MaxRMFaultSize);
|
|
WsrmHeaderFault wsrmFault;
|
|
|
|
if (soap11)
|
|
{
|
|
if (WsrmHeaderFault.TryCreateFault11(reliableMessagingVersion, message, messageInfo.faultInfo, sequenceFaultIndex, out wsrmFault))
|
|
{
|
|
messageInfo.faultInfo = wsrmFault;
|
|
messageInfo.faultException = WsrmHeaderFault.CreateException(wsrmFault);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (WsrmHeaderFault.TryCreateFault12(reliableMessagingVersion, message, messageInfo.faultInfo, out wsrmFault))
|
|
{
|
|
messageInfo.faultInfo = wsrmFault;
|
|
messageInfo.faultException = WsrmHeaderFault.CreateException(wsrmFault);
|
|
}
|
|
}
|
|
|
|
// Not a wsrm fault, maybe it is another fault we should understand (i.e. addressing or soap fault).
|
|
if (wsrmFault == null)
|
|
{
|
|
FaultConverter faultConverter = channel.GetProperty<FaultConverter>();
|
|
|
|
if (faultConverter == null)
|
|
{
|
|
faultConverter = FaultConverter.GetDefaultFaultConverter(messageVersion);
|
|
}
|
|
|
|
if (!faultConverter.TryCreateException(message, messageInfo.faultInfo, out messageInfo.faultException))
|
|
{
|
|
messageInfo.faultException = new ProtocolException(SR.GetString(SR.UnrecognizedFaultReceived, messageInfo.faultInfo.Code.Namespace, messageInfo.faultInfo.Code.Name, System.ServiceModel.FaultException.GetSafeReasonText(messageInfo.faultInfo)));
|
|
}
|
|
}
|
|
|
|
foundAction = true;
|
|
}
|
|
|
|
if (!foundHeader && !foundAction)
|
|
{
|
|
if (wsrmFeb2005)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new ActionNotSupportedException(SR.GetString(SR.NonWsrmFeb2005ActionNotSupported, action)));
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
CreateWsrmRequiredException(messageVersion));
|
|
}
|
|
}
|
|
|
|
if (foundAction || WsrmUtilities.IsWsrmAction(reliableMessagingVersion, action))
|
|
{
|
|
ValidateMustUnderstand(messageVersion, message);
|
|
}
|
|
}
|
|
catch (InternalFaultException exception)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
|
|
|
|
messageInfo.FaultReply = exception.FaultReply;
|
|
messageInfo.faultException = exception.InnerException;
|
|
}
|
|
catch (CommunicationException exception)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
|
|
|
|
if (isFault)
|
|
{
|
|
messageInfo.parsingException = exception;
|
|
return messageInfo;
|
|
}
|
|
|
|
FaultConverter faultConverter = channel.GetProperty<FaultConverter>();
|
|
if (faultConverter == null)
|
|
faultConverter = FaultConverter.GetDefaultFaultConverter(messageVersion);
|
|
|
|
if (faultConverter.TryCreateFaultMessage(exception, out messageInfo.faultReply))
|
|
{
|
|
messageInfo.faultException = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), exception);
|
|
}
|
|
else
|
|
{
|
|
messageInfo.parsingException = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), exception);
|
|
}
|
|
}
|
|
catch (XmlException exception)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);
|
|
|
|
messageInfo.parsingException = new ProtocolException(SR.GetString(SR.MessageExceptionOccurred), exception);
|
|
}
|
|
|
|
return messageInfo;
|
|
}
|
|
|
|
static void ValidateMustUnderstand(MessageVersion version, Message message)
|
|
{
|
|
Collection<MessageHeaderInfo> notUnderstoodHeaders = message.Headers.GetHeadersNotUnderstood();
|
|
if ((notUnderstoodHeaders != null) && (notUnderstoodHeaders.Count > 0))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MustUnderstandSoapException(notUnderstoodHeaders, version.Envelope));
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
class InternalFaultException : ProtocolException
|
|
{
|
|
Message faultReply;
|
|
|
|
public InternalFaultException()
|
|
: base()
|
|
{
|
|
}
|
|
|
|
public InternalFaultException(Message faultReply, string message, Exception inner)
|
|
: base(message, inner)
|
|
{
|
|
this.faultReply = faultReply;
|
|
}
|
|
|
|
protected InternalFaultException(SerializationInfo info, StreamingContext context)
|
|
: base(info, context)
|
|
{
|
|
}
|
|
|
|
public Message FaultReply
|
|
{
|
|
get
|
|
{
|
|
return this.faultReply;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
sealed class CloseSequenceInfo : WsrmRequestInfo
|
|
{
|
|
UniqueId identifier;
|
|
Int64 lastMsgNumber;
|
|
|
|
public UniqueId Identifier
|
|
{
|
|
get
|
|
{
|
|
return this.identifier;
|
|
}
|
|
set
|
|
{
|
|
this.identifier = value;
|
|
}
|
|
}
|
|
|
|
public Int64 LastMsgNumber
|
|
{
|
|
get
|
|
{
|
|
return this.lastMsgNumber;
|
|
}
|
|
set
|
|
{
|
|
this.lastMsgNumber = value;
|
|
}
|
|
}
|
|
|
|
public override string RequestName
|
|
{
|
|
get
|
|
{
|
|
return Wsrm11Strings.CloseSequence;
|
|
}
|
|
}
|
|
|
|
public static CloseSequenceInfo ReadMessage(MessageVersion messageVersion, Message message,
|
|
MessageHeaders headers)
|
|
{
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty, Wsrm11Strings.CloseSequenceAction);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
|
|
}
|
|
|
|
CloseSequenceInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = CloseSequence.Create(reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
info.SetMessageId(messageVersion, headers);
|
|
info.SetReplyTo(messageVersion, headers);
|
|
|
|
return info;
|
|
}
|
|
}
|
|
|
|
sealed class CloseSequenceResponseInfo
|
|
{
|
|
UniqueId identifier;
|
|
UniqueId relatesTo;
|
|
|
|
public UniqueId Identifier
|
|
{
|
|
get
|
|
{
|
|
return this.identifier;
|
|
}
|
|
set
|
|
{
|
|
this.identifier = value;
|
|
}
|
|
}
|
|
|
|
public UniqueId RelatesTo
|
|
{
|
|
get
|
|
{
|
|
return this.relatesTo;
|
|
}
|
|
set
|
|
{
|
|
this.relatesTo = value;
|
|
}
|
|
}
|
|
|
|
public static CloseSequenceResponseInfo ReadMessage(MessageVersion messageVersion, Message message,
|
|
MessageHeaders headers)
|
|
{
|
|
if (headers.RelatesTo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MessageHeaderException(SR.GetString(SR.MissingRelatesToOnWsrmResponseReason,
|
|
DXD.Wsrm11Dictionary.CloseSequenceResponse), messageVersion.Addressing.Namespace,
|
|
AddressingStrings.RelatesTo, false));
|
|
}
|
|
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty,
|
|
Wsrm11Strings.CloseSequenceResponseAction);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
|
|
}
|
|
|
|
CloseSequenceResponseInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = CloseSequenceResponse.Create(reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
info.relatesTo = headers.RelatesTo;
|
|
return info;
|
|
}
|
|
}
|
|
|
|
sealed class CreateSequenceInfo : WsrmRequestInfo
|
|
{
|
|
EndpointAddress acksTo = EndpointAddress.AnonymousAddress;
|
|
Nullable<TimeSpan> expires;
|
|
Nullable<TimeSpan> offerExpires;
|
|
UniqueId offerIdentifier;
|
|
Uri to;
|
|
|
|
public EndpointAddress AcksTo
|
|
{
|
|
get
|
|
{
|
|
return this.acksTo;
|
|
}
|
|
set
|
|
{
|
|
this.acksTo = value;
|
|
}
|
|
}
|
|
|
|
public Nullable<TimeSpan> Expires
|
|
{
|
|
get
|
|
{
|
|
return this.expires;
|
|
}
|
|
set
|
|
{
|
|
this.expires = value;
|
|
}
|
|
}
|
|
|
|
public Nullable<TimeSpan> OfferExpires
|
|
{
|
|
get
|
|
{
|
|
return this.offerExpires;
|
|
}
|
|
set
|
|
{
|
|
this.offerExpires = value;
|
|
}
|
|
}
|
|
|
|
public UniqueId OfferIdentifier
|
|
{
|
|
get
|
|
{
|
|
return this.offerIdentifier;
|
|
}
|
|
set
|
|
{
|
|
this.offerIdentifier = value;
|
|
}
|
|
}
|
|
|
|
public override string RequestName
|
|
{
|
|
get
|
|
{
|
|
return WsrmFeb2005Strings.CreateSequence;
|
|
}
|
|
}
|
|
|
|
public Uri To
|
|
{
|
|
get
|
|
{
|
|
return this.to;
|
|
}
|
|
}
|
|
|
|
public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession,
|
|
Message message, MessageHeaders headers)
|
|
{
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty,
|
|
WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion));
|
|
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
|
|
}
|
|
|
|
CreateSequenceInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
info.SetMessageId(messageVersion, headers);
|
|
info.SetReplyTo(messageVersion, headers);
|
|
|
|
if (info.AcksTo.Uri != info.ReplyTo.Uri)
|
|
{
|
|
string reason = SR.GetString(SR.CSRefusedAcksToMustEqualReplyTo);
|
|
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
|
|
}
|
|
|
|
info.to = message.Headers.To;
|
|
if (info.to == null && messageVersion.Addressing == AddressingVersion.WSAddressing10)
|
|
info.to = messageVersion.Addressing.AnonymousUri;
|
|
|
|
return info;
|
|
}
|
|
|
|
public static void ValidateCreateSequenceHeaders(MessageVersion messageVersion,
|
|
ISecureConversationSession securitySession, WsrmMessageInfo info)
|
|
{
|
|
string reason = null;
|
|
|
|
if (info.UsesSequenceSSLInfo != null)
|
|
{
|
|
reason = SR.GetString(SR.CSRefusedSSLNotSupported);
|
|
}
|
|
else if ((info.UsesSequenceSTRInfo != null) && (securitySession == null))
|
|
{
|
|
reason = SR.GetString(SR.CSRefusedSTRNoWSSecurity);
|
|
}
|
|
else if ((info.UsesSequenceSTRInfo == null) && (securitySession != null))
|
|
{
|
|
reason = SR.GetString(SR.CSRefusedNoSTRWSSecurity);
|
|
}
|
|
|
|
if (reason != null)
|
|
{
|
|
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion,
|
|
ReliableMessagingVersion.WSReliableMessaging11, reason);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
|
|
}
|
|
}
|
|
}
|
|
|
|
sealed class CreateSequenceResponseInfo
|
|
{
|
|
EndpointAddress acceptAcksTo;
|
|
UniqueId identifier;
|
|
UniqueId relatesTo;
|
|
|
|
public EndpointAddress AcceptAcksTo
|
|
{
|
|
get
|
|
{
|
|
return this.acceptAcksTo;
|
|
}
|
|
set
|
|
{
|
|
this.acceptAcksTo = value;
|
|
}
|
|
}
|
|
|
|
public UniqueId Identifier
|
|
{
|
|
get
|
|
{
|
|
return this.identifier;
|
|
}
|
|
set
|
|
{
|
|
this.identifier = value;
|
|
}
|
|
}
|
|
|
|
public UniqueId RelatesTo
|
|
{
|
|
get
|
|
{
|
|
return this.relatesTo;
|
|
}
|
|
set
|
|
{
|
|
this.relatesTo = value;
|
|
}
|
|
}
|
|
|
|
public static CreateSequenceResponseInfo ReadMessage(MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion, Message message, MessageHeaders headers)
|
|
{
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty,
|
|
WsrmIndex.GetCreateSequenceResponseActionString(reliableMessagingVersion));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
|
|
}
|
|
|
|
if (headers.RelatesTo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MessageHeaderException(SR.GetString(SR.MissingRelatesToOnWsrmResponseReason,
|
|
XD.WsrmFeb2005Dictionary.CreateSequenceResponse), messageVersion.Addressing.Namespace,
|
|
AddressingStrings.RelatesTo, false));
|
|
}
|
|
|
|
CreateSequenceResponseInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = CreateSequenceResponse.Create(messageVersion.Addressing, reliableMessagingVersion, reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
info.RelatesTo = headers.RelatesTo;
|
|
return info;
|
|
}
|
|
}
|
|
|
|
sealed class TerminateSequenceInfo : WsrmRequestInfo
|
|
{
|
|
UniqueId identifier;
|
|
Int64 lastMsgNumber;
|
|
|
|
public UniqueId Identifier
|
|
{
|
|
get
|
|
{
|
|
return this.identifier;
|
|
}
|
|
set
|
|
{
|
|
this.identifier = value;
|
|
}
|
|
}
|
|
|
|
public Int64 LastMsgNumber
|
|
{
|
|
get
|
|
{
|
|
return this.lastMsgNumber;
|
|
}
|
|
set
|
|
{
|
|
this.lastMsgNumber = value;
|
|
}
|
|
}
|
|
|
|
public override string RequestName
|
|
{
|
|
get
|
|
{
|
|
return WsrmFeb2005Strings.TerminateSequence;
|
|
}
|
|
}
|
|
|
|
public static TerminateSequenceInfo ReadMessage(MessageVersion messageVersion,
|
|
ReliableMessagingVersion reliableMessagingVersion, Message message, MessageHeaders headers)
|
|
{
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty,
|
|
WsrmIndex.GetTerminateSequenceActionString(reliableMessagingVersion));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
|
|
}
|
|
|
|
TerminateSequenceInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = TerminateSequence.Create(reliableMessagingVersion, reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
info.SetMessageId(messageVersion, headers);
|
|
info.SetReplyTo(messageVersion, headers);
|
|
}
|
|
|
|
return info;
|
|
}
|
|
}
|
|
|
|
sealed class TerminateSequenceResponseInfo
|
|
{
|
|
UniqueId identifier;
|
|
UniqueId relatesTo;
|
|
|
|
public UniqueId Identifier
|
|
{
|
|
get
|
|
{
|
|
return this.identifier;
|
|
}
|
|
set
|
|
{
|
|
this.identifier = value;
|
|
}
|
|
}
|
|
|
|
public UniqueId RelatesTo
|
|
{
|
|
get
|
|
{
|
|
return this.relatesTo;
|
|
}
|
|
set
|
|
{
|
|
this.relatesTo = value;
|
|
}
|
|
}
|
|
|
|
public static TerminateSequenceResponseInfo ReadMessage(MessageVersion messageVersion, Message message,
|
|
MessageHeaders headers)
|
|
{
|
|
if (headers.RelatesTo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new MessageHeaderException(SR.GetString(SR.MissingRelatesToOnWsrmResponseReason,
|
|
DXD.Wsrm11Dictionary.TerminateSequenceResponse), messageVersion.Addressing.Namespace,
|
|
AddressingStrings.RelatesTo, false));
|
|
}
|
|
|
|
if (message.IsEmpty)
|
|
{
|
|
string reason = SR.GetString(SR.NonEmptyWsrmMessageIsEmpty,
|
|
WsrmIndex.GetTerminateSequenceResponseActionString(ReliableMessagingVersion.WSReliableMessaging11));
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(reason));
|
|
}
|
|
|
|
TerminateSequenceResponseInfo info;
|
|
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
|
|
{
|
|
info = TerminateSequenceResponse.Create(reader);
|
|
message.ReadFromBodyContentsToEnd(reader);
|
|
}
|
|
|
|
info.relatesTo = headers.RelatesTo;
|
|
return info;
|
|
}
|
|
}
|
|
|
|
internal abstract class WsrmMessageHeader : DictionaryHeader, IMessageHeaderWithSharedNamespace
|
|
{
|
|
ReliableMessagingVersion reliableMessagingVersion;
|
|
|
|
protected WsrmMessageHeader(ReliableMessagingVersion reliableMessagingVersion)
|
|
{
|
|
this.reliableMessagingVersion = reliableMessagingVersion;
|
|
}
|
|
|
|
XmlDictionaryString IMessageHeaderWithSharedNamespace.SharedPrefix
|
|
{
|
|
get { return XD.WsrmFeb2005Dictionary.Prefix; }
|
|
}
|
|
|
|
XmlDictionaryString IMessageHeaderWithSharedNamespace.SharedNamespace
|
|
{
|
|
get { return WsrmIndex.GetNamespace(this.reliableMessagingVersion); }
|
|
}
|
|
|
|
public override XmlDictionaryString DictionaryNamespace
|
|
{
|
|
get { return WsrmIndex.GetNamespace(this.reliableMessagingVersion); }
|
|
}
|
|
|
|
public override string Namespace
|
|
{
|
|
get { return WsrmIndex.GetNamespaceString(this.reliableMessagingVersion); }
|
|
}
|
|
|
|
protected ReliableMessagingVersion ReliableMessagingVersion
|
|
{
|
|
get { return this.reliableMessagingVersion; }
|
|
}
|
|
}
|
|
|
|
abstract class WsrmHeaderInfo
|
|
{
|
|
MessageHeaderInfo messageHeader;
|
|
|
|
protected WsrmHeaderInfo(MessageHeaderInfo messageHeader)
|
|
{
|
|
this.messageHeader = messageHeader;
|
|
}
|
|
|
|
public MessageHeaderInfo MessageHeader
|
|
{
|
|
get
|
|
{
|
|
return messageHeader;
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class WsrmRequestInfo
|
|
{
|
|
UniqueId messageId;
|
|
EndpointAddress replyTo;
|
|
|
|
protected WsrmRequestInfo()
|
|
{
|
|
}
|
|
|
|
public UniqueId MessageId
|
|
{
|
|
get
|
|
{
|
|
return this.messageId;
|
|
}
|
|
}
|
|
|
|
public EndpointAddress ReplyTo
|
|
{
|
|
get
|
|
{
|
|
return this.replyTo;
|
|
}
|
|
}
|
|
|
|
public abstract string RequestName
|
|
{
|
|
get;
|
|
}
|
|
|
|
protected void SetMessageId(MessageVersion messageVersion, MessageHeaders headers)
|
|
{
|
|
this.messageId = headers.MessageId;
|
|
|
|
if (this.messageId == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(
|
|
SR.GetString(SR.MissingMessageIdOnWsrmRequest, RequestName),
|
|
messageVersion.Addressing.Namespace,
|
|
AddressingStrings.MessageId,
|
|
false));
|
|
}
|
|
}
|
|
|
|
protected void SetReplyTo(MessageVersion messageVersion, MessageHeaders headers)
|
|
{
|
|
this.replyTo = headers.ReplyTo;
|
|
|
|
if (messageVersion.Addressing == AddressingVersion.WSAddressing10 && this.replyTo == null)
|
|
{
|
|
this.replyTo = EndpointAddress.AnonymousAddress;
|
|
}
|
|
|
|
if (this.replyTo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(
|
|
SR.GetString(SR.MissingReplyToOnWsrmRequest, RequestName),
|
|
messageVersion.Addressing.Namespace,
|
|
AddressingStrings.ReplyTo,
|
|
false));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmSequencedMessageInfo : WsrmHeaderInfo
|
|
{
|
|
UniqueId sequenceID;
|
|
Int64 sequenceNumber;
|
|
bool lastMessage;
|
|
|
|
WsrmSequencedMessageInfo(
|
|
UniqueId sequenceID,
|
|
Int64 sequenceNumber,
|
|
bool lastMessage,
|
|
MessageHeaderInfo header)
|
|
: base(header)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
this.sequenceNumber = sequenceNumber;
|
|
this.lastMessage = lastMessage;
|
|
}
|
|
|
|
public UniqueId SequenceID
|
|
{
|
|
get
|
|
{
|
|
return sequenceID;
|
|
}
|
|
}
|
|
|
|
public Int64 SequenceNumber
|
|
{
|
|
get
|
|
{
|
|
return sequenceNumber;
|
|
}
|
|
}
|
|
|
|
public bool LastMessage
|
|
{
|
|
get
|
|
{
|
|
return lastMessage;
|
|
}
|
|
}
|
|
|
|
public static WsrmSequencedMessageInfo ReadHeader(ReliableMessagingVersion reliableMessagingVersion,
|
|
XmlDictionaryReader reader, MessageHeaderInfo header)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
|
|
|
|
reader.ReadStartElement();
|
|
|
|
reader.ReadStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
UniqueId sequenceID = reader.ReadContentAsUniqueId();
|
|
reader.ReadEndElement();
|
|
|
|
reader.ReadStartElement(wsrmFeb2005Dictionary.MessageNumber, wsrmNs);
|
|
Int64 sequenceNumber = WsrmUtilities.ReadSequenceNumber(reader);
|
|
reader.ReadEndElement();
|
|
|
|
bool lastMessage = false;
|
|
|
|
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
if (reader.IsStartElement(wsrmFeb2005Dictionary.LastMessage, wsrmNs))
|
|
{
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
lastMessage = true;
|
|
}
|
|
}
|
|
|
|
while (reader.IsStartElement())
|
|
{
|
|
reader.Skip();
|
|
}
|
|
|
|
reader.ReadEndElement();
|
|
|
|
return new WsrmSequencedMessageInfo(sequenceID, sequenceNumber, lastMessage, header);
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmSequencedMessageHeader : WsrmMessageHeader
|
|
{
|
|
bool lastMessage;
|
|
UniqueId sequenceID;
|
|
Int64 sequenceNumber;
|
|
|
|
public WsrmSequencedMessageHeader(
|
|
ReliableMessagingVersion reliableMessagingVersion,
|
|
UniqueId sequenceID,
|
|
Int64 sequenceNumber,
|
|
bool lastMessage)
|
|
: base(reliableMessagingVersion)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
this.sequenceNumber = sequenceNumber;
|
|
this.lastMessage = lastMessage;
|
|
}
|
|
|
|
public override XmlDictionaryString DictionaryName
|
|
{
|
|
get { return XD.WsrmFeb2005Dictionary.Sequence; }
|
|
}
|
|
|
|
public override bool MustUnderstand
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = this.DictionaryNamespace;
|
|
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
writer.WriteValue(this.sequenceID);
|
|
writer.WriteEndElement();
|
|
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.MessageNumber, wsrmNs);
|
|
writer.WriteValue(this.sequenceNumber);
|
|
writer.WriteEndElement();
|
|
|
|
if ((this.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
&& lastMessage)
|
|
{
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.LastMessage, wsrmNs);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmAcknowledgmentInfo : WsrmHeaderInfo
|
|
{
|
|
int bufferRemaining;
|
|
bool final;
|
|
SequenceRangeCollection ranges;
|
|
UniqueId sequenceID;
|
|
|
|
WsrmAcknowledgmentInfo(
|
|
UniqueId sequenceID,
|
|
SequenceRangeCollection ranges,
|
|
bool final,
|
|
int bufferRemaining,
|
|
MessageHeaderInfo header)
|
|
: base(header)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
this.ranges = ranges;
|
|
this.final = final;
|
|
this.bufferRemaining = bufferRemaining;
|
|
}
|
|
|
|
public int BufferRemaining
|
|
{
|
|
get
|
|
{
|
|
return this.bufferRemaining;
|
|
}
|
|
}
|
|
|
|
public bool Final
|
|
{
|
|
get
|
|
{
|
|
return this.final;
|
|
}
|
|
}
|
|
|
|
public SequenceRangeCollection Ranges
|
|
{
|
|
get
|
|
{
|
|
return this.ranges;
|
|
}
|
|
}
|
|
|
|
public UniqueId SequenceID
|
|
{
|
|
get
|
|
{
|
|
return this.sequenceID;
|
|
}
|
|
}
|
|
|
|
// February 2005 - Reads Identifier, AcknowledgementRange, Nack
|
|
// 1.1 - Reads Identifier, AcknowledgementRange, None, Final, Nack
|
|
internal static void ReadAck(ReliableMessagingVersion reliableMessagingVersion,
|
|
XmlDictionaryReader reader, out UniqueId sequenceId, out SequenceRangeCollection rangeCollection,
|
|
out bool final)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
|
|
|
|
reader.ReadStartElement(wsrmFeb2005Dictionary.SequenceAcknowledgement, wsrmNs);
|
|
reader.ReadStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
sequenceId = reader.ReadContentAsUniqueId();
|
|
reader.ReadEndElement();
|
|
bool allowZero = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005;
|
|
|
|
rangeCollection = SequenceRangeCollection.Empty;
|
|
while (reader.IsStartElement(wsrmFeb2005Dictionary.AcknowledgementRange, wsrmNs))
|
|
{
|
|
reader.MoveToAttribute(WsrmFeb2005Strings.Lower);
|
|
Int64 lower = WsrmUtilities.ReadSequenceNumber(reader, allowZero);
|
|
|
|
reader.MoveToAttribute(WsrmFeb2005Strings.Upper);
|
|
Int64 upper = WsrmUtilities.ReadSequenceNumber(reader, allowZero);
|
|
|
|
if (lower < 0 || lower > upper
|
|
|| ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005) && (lower == 0 && upper > 0))
|
|
|| ((reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && (lower == 0)))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new XmlException(SR.GetString(SR.InvalidSequenceRange, lower, upper)));
|
|
}
|
|
|
|
rangeCollection = rangeCollection.MergeWith(new SequenceRange(lower, upper));
|
|
|
|
reader.MoveToElement();
|
|
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
}
|
|
|
|
bool validAck = rangeCollection.Count > 0;
|
|
final = false;
|
|
bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
|
|
|
|
if (wsrm11)
|
|
{
|
|
Wsrm11Dictionary wsrm11Dictionary = DXD.Wsrm11Dictionary;
|
|
|
|
if (reader.IsStartElement(wsrm11Dictionary.None, wsrmNs))
|
|
{
|
|
if (validAck)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
wsrmFeb2005Dictionary.SequenceAcknowledgement)));
|
|
}
|
|
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
validAck = true;
|
|
}
|
|
|
|
if (reader.IsStartElement(wsrm11Dictionary.Final, wsrmNs))
|
|
{
|
|
if (!validAck)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
wsrmFeb2005Dictionary.SequenceAcknowledgement)));
|
|
}
|
|
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
final = true;
|
|
}
|
|
}
|
|
|
|
bool foundNack = false;
|
|
while (reader.IsStartElement(wsrmFeb2005Dictionary.Nack, wsrmNs))
|
|
{
|
|
if (validAck)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
MessageStrings.Body)));
|
|
}
|
|
|
|
reader.ReadStartElement();
|
|
WsrmUtilities.ReadSequenceNumber(reader, true);
|
|
reader.ReadEndElement();
|
|
foundNack = true;
|
|
}
|
|
|
|
if (!validAck && !foundNack)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
MessageStrings.Body)));
|
|
}
|
|
}
|
|
|
|
public static WsrmAcknowledgmentInfo ReadHeader(ReliableMessagingVersion reliableMessagingVersion,
|
|
XmlDictionaryReader reader, MessageHeaderInfo header)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
|
|
|
|
UniqueId sequenceID;
|
|
SequenceRangeCollection rangeCollection;
|
|
bool final;
|
|
ReadAck(reliableMessagingVersion, reader, out sequenceID, out rangeCollection, out final);
|
|
|
|
int bufferRemaining = -1;
|
|
|
|
// Parse the extensibility section.
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(wsrmFeb2005Dictionary.BufferRemaining,
|
|
XD.WsrmFeb2005Dictionary.NETNamespace))
|
|
{
|
|
if (bufferRemaining != -1)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
MessageStrings.Body)));
|
|
}
|
|
|
|
reader.ReadStartElement();
|
|
bufferRemaining = reader.ReadContentAsInt();
|
|
reader.ReadEndElement();
|
|
|
|
if (bufferRemaining < 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.InvalidBufferRemaining, bufferRemaining)));
|
|
}
|
|
|
|
// Found BufferRemaining, continue parsing.
|
|
continue;
|
|
}
|
|
|
|
if (reader.IsStartElement(wsrmFeb2005Dictionary.AcknowledgementRange, wsrmNs))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
MessageStrings.Body)));
|
|
}
|
|
else if (reader.IsStartElement(wsrmFeb2005Dictionary.Nack, wsrmNs))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
MessageStrings.Body)));
|
|
}
|
|
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
Wsrm11Dictionary wsrm11Dictionary = DXD.Wsrm11Dictionary;
|
|
|
|
if (reader.IsStartElement(wsrm11Dictionary.None, wsrmNs)
|
|
|| reader.IsStartElement(wsrm11Dictionary.Final, wsrmNs))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(
|
|
SR.GetString(SR.UnexpectedXmlChildNode, reader.Name, reader.NodeType,
|
|
wsrmFeb2005Dictionary.SequenceAcknowledgement)));
|
|
}
|
|
}
|
|
|
|
// Advance the reader in all cases.
|
|
reader.Skip();
|
|
}
|
|
|
|
reader.ReadEndElement();
|
|
|
|
return new WsrmAcknowledgmentInfo(sequenceID, rangeCollection, final, bufferRemaining, header);
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmAcknowledgmentHeader : WsrmMessageHeader
|
|
{
|
|
int bufferRemaining;
|
|
bool final;
|
|
SequenceRangeCollection ranges;
|
|
UniqueId sequenceID;
|
|
|
|
public WsrmAcknowledgmentHeader(
|
|
ReliableMessagingVersion reliableMessagingVersion,
|
|
UniqueId sequenceID,
|
|
SequenceRangeCollection ranges,
|
|
bool final,
|
|
int bufferRemaining)
|
|
: base(reliableMessagingVersion)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
this.ranges = ranges;
|
|
this.final = final;
|
|
this.bufferRemaining = bufferRemaining;
|
|
}
|
|
|
|
public override XmlDictionaryString DictionaryName
|
|
{
|
|
get { return XD.WsrmFeb2005Dictionary.SequenceAcknowledgement; }
|
|
}
|
|
|
|
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = this.DictionaryNamespace;
|
|
|
|
WriteAckRanges(writer, this.ReliableMessagingVersion, this.sequenceID, this.ranges);
|
|
|
|
if ((this.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) && this.final)
|
|
{
|
|
writer.WriteStartElement(DXD.Wsrm11Dictionary.Final, wsrmNs);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
if (this.bufferRemaining != -1)
|
|
{
|
|
writer.WriteStartElement(WsrmFeb2005Strings.NETPrefix, wsrmFeb2005Dictionary.BufferRemaining,
|
|
XD.WsrmFeb2005Dictionary.NETNamespace);
|
|
writer.WriteValue(this.bufferRemaining);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
// February 2005 - Writes Identifier, AcknowledgementRange
|
|
// 1.1 - Writes Identifier, AcknowledgementRange | None
|
|
internal static void WriteAckRanges(XmlDictionaryWriter writer,
|
|
ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceId, SequenceRangeCollection ranges)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
|
|
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
writer.WriteValue(sequenceId);
|
|
writer.WriteEndElement();
|
|
|
|
if (ranges.Count == 0)
|
|
{
|
|
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
ranges = ranges.MergeWith(0);
|
|
}
|
|
else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
writer.WriteStartElement(DXD.Wsrm11Dictionary.None, wsrmNs);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
for (int index = 0; index < ranges.Count; index++)
|
|
{
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.AcknowledgementRange, wsrmNs);
|
|
writer.WriteStartAttribute(wsrmFeb2005Dictionary.Lower, null);
|
|
writer.WriteValue(ranges[index].Lower);
|
|
writer.WriteEndAttribute();
|
|
writer.WriteStartAttribute(wsrmFeb2005Dictionary.Upper, null);
|
|
writer.WriteValue(ranges[index].Upper);
|
|
writer.WriteEndAttribute();
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmAckRequestedInfo : WsrmHeaderInfo
|
|
{
|
|
UniqueId sequenceID;
|
|
|
|
public WsrmAckRequestedInfo(UniqueId sequenceID, MessageHeaderInfo header)
|
|
: base(header)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
}
|
|
|
|
public UniqueId SequenceID
|
|
{
|
|
get
|
|
{
|
|
return this.sequenceID;
|
|
}
|
|
}
|
|
|
|
public static WsrmAckRequestedInfo ReadHeader(ReliableMessagingVersion reliableMessagingVersion,
|
|
XmlDictionaryReader reader, MessageHeaderInfo header)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
|
|
|
|
reader.ReadStartElement();
|
|
|
|
reader.ReadStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
UniqueId sequenceID = reader.ReadContentAsUniqueId();
|
|
reader.ReadEndElement();
|
|
|
|
if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
|
|
{
|
|
if (reader.IsStartElement(wsrmFeb2005Dictionary.MessageNumber, wsrmNs))
|
|
{
|
|
reader.ReadStartElement();
|
|
WsrmUtilities.ReadSequenceNumber(reader, true);
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
while (reader.IsStartElement())
|
|
{
|
|
reader.Skip();
|
|
}
|
|
|
|
reader.ReadEndElement();
|
|
|
|
return new WsrmAckRequestedInfo(sequenceID, header);
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmAckRequestedHeader : WsrmMessageHeader
|
|
{
|
|
UniqueId sequenceID;
|
|
|
|
public WsrmAckRequestedHeader(ReliableMessagingVersion reliableMessagingVersion, UniqueId sequenceID)
|
|
: base(reliableMessagingVersion)
|
|
{
|
|
this.sequenceID = sequenceID;
|
|
}
|
|
|
|
public override XmlDictionaryString DictionaryName
|
|
{
|
|
get { return XD.WsrmFeb2005Dictionary.AckRequested; }
|
|
}
|
|
|
|
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
|
|
{
|
|
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
|
|
XmlDictionaryString wsrmNs = this.DictionaryNamespace;
|
|
|
|
writer.WriteStartElement(wsrmFeb2005Dictionary.Identifier, wsrmNs);
|
|
writer.WriteValue(this.sequenceID);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
// We do not generate the UsesSequenceSSL header. Thus, there is an info, but no header.
|
|
internal sealed class WsrmUsesSequenceSSLInfo : WsrmHeaderInfo
|
|
{
|
|
WsrmUsesSequenceSSLInfo(MessageHeaderInfo header)
|
|
: base(header)
|
|
{
|
|
}
|
|
|
|
public static WsrmUsesSequenceSSLInfo ReadHeader(XmlDictionaryReader reader, MessageHeaderInfo header)
|
|
{
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
return new WsrmUsesSequenceSSLInfo(header);
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmUsesSequenceSTRHeader : WsrmMessageHeader
|
|
{
|
|
public WsrmUsesSequenceSTRHeader()
|
|
: base(ReliableMessagingVersion.WSReliableMessaging11)
|
|
{
|
|
}
|
|
|
|
public override XmlDictionaryString DictionaryName
|
|
{
|
|
get { return DXD.Wsrm11Dictionary.UsesSequenceSTR; }
|
|
}
|
|
|
|
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
|
|
{
|
|
}
|
|
|
|
public override bool MustUnderstand
|
|
{
|
|
get { return true; }
|
|
}
|
|
}
|
|
|
|
internal sealed class WsrmUsesSequenceSTRInfo : WsrmHeaderInfo
|
|
{
|
|
WsrmUsesSequenceSTRInfo(MessageHeaderInfo header)
|
|
: base(header)
|
|
{
|
|
}
|
|
|
|
public static WsrmUsesSequenceSTRInfo ReadHeader(XmlDictionaryReader reader, MessageHeaderInfo header)
|
|
{
|
|
WsrmUtilities.ReadEmptyElement(reader);
|
|
return new WsrmUsesSequenceSTRInfo(header);
|
|
}
|
|
}
|
|
}
|