|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections;
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.Xml;
static class ReliableSessionPolicyStrings
{
public const string AcknowledgementInterval = "AcknowledgementInterval";
public const string AtLeastOnce = "AtLeastOnce";
public const string AtMostOnce = "AtMostOnce";
public const string BaseRetransmissionInterval = "BaseRetransmissionInterval";
public const string DeliveryAssurance = "DeliveryAssurance";
public const string ExactlyOnce = "ExactlyOnce";
public const string ExponentialBackoff = "ExponentialBackoff";
public const string InactivityTimeout = "InactivityTimeout";
public const string InOrder = "InOrder";
public const string Milliseconds = "Milliseconds";
public const string NET11Namespace = "http://schemas.microsoft.com/ws-rx/wsrmp/200702";
public const string NET11Prefix = "netrmp";
public const string ReliableSessionName = "RMAssertion";
public const string ReliableSessionFebruary2005Namespace = "http://schemas.xmlsoap.org/ws/2005/02/rm/policy";
public const string ReliableSessionFebruary2005Prefix = "wsrm";
public const string ReliableSession11Namespace = "http://docs.oasis-open.org/ws-rx/wsrmp/200702";
public const string ReliableSession11Prefix = "wsrmp";
public const string SequenceSTR = "SequenceSTR";
public const string SequenceTransportSecurity = "SequenceTransportSecurity";
}
public sealed class ReliableSessionBindingElementImporter : IPolicyImportExtension
{
void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
{
if (importer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("importer");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
bool gotAssertion = false;
XmlElement reliableSessionAssertion = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(),
ReliableSessionPolicyStrings.ReliableSessionName,
ReliableSessionPolicyStrings.ReliableSessionFebruary2005Namespace, true);
if (reliableSessionAssertion != null)
{
ProcessReliableSessionFeb2005Assertion(reliableSessionAssertion, GetReliableSessionBindingElement(context));
gotAssertion = true;
}
reliableSessionAssertion = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(),
ReliableSessionPolicyStrings.ReliableSessionName,
ReliableSessionPolicyStrings.ReliableSession11Namespace, true);
if (reliableSessionAssertion != null)
{
if (gotAssertion)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(
SR.GetString(SR.MultipleVersionsFoundInPolicy,
ReliableSessionPolicyStrings.ReliableSessionName)));
}
ProcessReliableSession11Assertion(importer, reliableSessionAssertion,
GetReliableSessionBindingElement(context));
}
}
static ReliableSessionBindingElement GetReliableSessionBindingElement(PolicyConversionContext context)
{
ReliableSessionBindingElement settings = context.BindingElements.Find<ReliableSessionBindingElement>();
if (settings == null)
{
settings = new ReliableSessionBindingElement();
context.BindingElements.Add(settings);
}
return settings;
}
static bool Is11Assertion(XmlNode node, string assertion)
{
return IsElement(node, ReliableSessionPolicyStrings.NET11Namespace, assertion);
}
static bool IsElement(XmlNode node, string ns, string assertion)
{
if (assertion == null)
{
throw Fx.AssertAndThrow("Argument assertion cannot be null.");
}
return ((node != null)
&& (node.NodeType == XmlNodeType.Element)
&& (node.NamespaceURI == ns)
&& (node.LocalName == assertion));
}
static bool IsFeb2005Assertion(XmlNode node, string assertion)
{
return IsElement(node, ReliableSessionPolicyStrings.ReliableSessionFebruary2005Namespace, assertion);
}
static void ProcessReliableSession11Assertion(MetadataImporter importer, XmlElement element,
ReliableSessionBindingElement settings)
{
// Version
settings.ReliableMessagingVersion = ReliableMessagingVersion.WSReliableMessaging11;
IEnumerator assertionChildren = element.ChildNodes.GetEnumerator();
XmlNode currentNode = SkipToNode(assertionChildren);
// Policy
ProcessWsrm11Policy(importer, currentNode, settings);
currentNode = SkipToNode(assertionChildren);
// Looking for:
// InactivityTimeout, AcknowledgementInterval
// InactivityTimeout
// AcknowledgementInterval
// or nothing at all.
State state = State.InactivityTimeout;
while (currentNode != null)
{
if (state == State.InactivityTimeout)
{
// InactivityTimeout assertion
if (Is11Assertion(currentNode, ReliableSessionPolicyStrings.InactivityTimeout))
{
SetInactivityTimeout(settings, ReadMillisecondsAttribute(currentNode, true), currentNode.LocalName);
state = State.AcknowledgementInterval;
currentNode = SkipToNode(assertionChildren);
continue;
}
}
// AcknowledgementInterval assertion
if (Is11Assertion(currentNode, ReliableSessionPolicyStrings.AcknowledgementInterval))
{
SetAcknowledgementInterval(settings, ReadMillisecondsAttribute(currentNode, true), currentNode.LocalName);
// ignore the rest
break;
}
if (state == State.AcknowledgementInterval)
{
// ignore the rest
break;
}
currentNode = SkipToNode(assertionChildren);
}
// Schema allows arbitrary elements from now on, ignore everything else
}
static void ProcessReliableSessionFeb2005Assertion(XmlElement element, ReliableSessionBindingElement settings)
{
// Version
settings.ReliableMessagingVersion = ReliableMessagingVersion.WSReliableMessagingFebruary2005;
IEnumerator nodes = element.ChildNodes.GetEnumerator();
XmlNode currentNode = SkipToNode(nodes);
// InactivityTimeout assertion
if (IsFeb2005Assertion(currentNode, ReliableSessionPolicyStrings.InactivityTimeout))
{
SetInactivityTimeout(settings, ReadMillisecondsAttribute(currentNode, true), currentNode.LocalName);
currentNode = SkipToNode(nodes);
}
// BaseRetransmissionInterval assertion is read but ignored
if (IsFeb2005Assertion(currentNode, ReliableSessionPolicyStrings.BaseRetransmissionInterval))
{
ReadMillisecondsAttribute(currentNode, false);
currentNode = SkipToNode(nodes);
}
// ExponentialBackoff assertion is read but ignored
if (IsFeb2005Assertion(currentNode, ReliableSessionPolicyStrings.ExponentialBackoff))
{
currentNode = SkipToNode(nodes);
}
// AcknowledgementInterval assertion
if (IsFeb2005Assertion(currentNode, ReliableSessionPolicyStrings.AcknowledgementInterval))
{
SetAcknowledgementInterval(settings, ReadMillisecondsAttribute(currentNode, true), currentNode.LocalName);
}
// Schema allows arbitrary elements from now on, ignore everything else
}
static void ProcessWsrm11Policy(MetadataImporter importer, XmlNode node, ReliableSessionBindingElement settings)
{
XmlElement element = ThrowIfNotPolicyElement(node, ReliableMessagingVersion.WSReliableMessaging11);
IEnumerable<IEnumerable<XmlElement>> alternatives = importer.NormalizePolicy(new XmlElement[] { element });
List<Wsrm11PolicyAlternative> wsrmAlternatives = new List<Wsrm11PolicyAlternative>();
foreach (IEnumerable<XmlElement> alternative in alternatives)
{
Wsrm11PolicyAlternative wsrm11Policy = Wsrm11PolicyAlternative.ImportAlternative(importer, alternative);
wsrmAlternatives.Add(wsrm11Policy);
}
if (wsrmAlternatives.Count == 0)
{
// No specific policy other than turn on WS-RM.
return;
}
foreach (Wsrm11PolicyAlternative wsrmAlternative in wsrmAlternatives)
{
// The only policy setting that affects the binding is the InOrder assurance.
// Even that setting does not affect the binding since InOrder is a server delivery assurance.
// Transfer any that is valid.
if (wsrmAlternative.HasValidPolicy)
{
wsrmAlternative.TransferSettings(settings);
return;
}
}
// Found only invalid policy.
// This throws an exception about security since that is the only invalid policy we have.
Wsrm11PolicyAlternative.ThrowInvalidBindingException();
}
static TimeSpan ReadMillisecondsAttribute(XmlNode wsrmNode, bool convertToTimeSpan)
{
XmlAttribute millisecondsAttribute = wsrmNode.Attributes[ReliableSessionPolicyStrings.Milliseconds];
if (millisecondsAttribute == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(SR.RequiredAttributeIsMissing, ReliableSessionPolicyStrings.Milliseconds, wsrmNode.LocalName, ReliableSessionPolicyStrings.ReliableSessionName)));
UInt64 milliseconds = 0;
Exception innerException = null;
try
{
milliseconds = XmlConvert.ToUInt64(millisecondsAttribute.Value);
}
catch (FormatException exception)
{
innerException = exception;
}
catch (OverflowException exception)
{
innerException = exception;
}
if (innerException != null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(SR.RequiredMillisecondsAttributeIncorrect, wsrmNode.LocalName), innerException));
if (convertToTimeSpan)
{
TimeSpan interval;
try
{
interval = TimeSpan.FromMilliseconds(Convert.ToDouble(milliseconds));
}
catch (OverflowException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(SR.MillisecondsNotConvertibleToBindingRange, wsrmNode.LocalName), exception));
}
return interval;
}
else
{
return default(TimeSpan);
}
}
static void SetInactivityTimeout(ReliableSessionBindingElement settings, TimeSpan inactivityTimeout, string localName)
{
try
{
settings.InactivityTimeout = inactivityTimeout;
}
catch (ArgumentOutOfRangeException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(
SR.GetString(SR.MillisecondsNotConvertibleToBindingRange, localName), exception));
}
}
static void SetAcknowledgementInterval(ReliableSessionBindingElement settings, TimeSpan acknowledgementInterval, string localName)
{
try
{
settings.AcknowledgementInterval = acknowledgementInterval;
}
catch (ArgumentOutOfRangeException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(SR.MillisecondsNotConvertibleToBindingRange, localName), exception));
}
}
static bool ShouldSkipNodeType(XmlNodeType type)
{
return (type == XmlNodeType.Comment || type == XmlNodeType.SignificantWhitespace || type == XmlNodeType.Whitespace || type == XmlNodeType.Notation);
}
static XmlNode SkipToNode(IEnumerator nodes)
{
while (nodes.MoveNext())
{
XmlNode currentNode = (XmlNode)nodes.Current;
if (ShouldSkipNodeType(currentNode.NodeType))
continue;
return currentNode;
}
return null;
}
static XmlElement ThrowIfNotPolicyElement(XmlNode node, ReliableMessagingVersion reliableMessagingVersion)
{
string policyLocalName = MetadataStrings.WSPolicy.Elements.Policy;
if (!IsElement(node, MetadataStrings.WSPolicy.NamespaceUri, policyLocalName)
&& !IsElement(node, MetadataStrings.WSPolicy.NamespaceUri15, policyLocalName))
{
string wsrmPrefix = (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
? ReliableSessionPolicyStrings.ReliableSessionFebruary2005Prefix
: ReliableSessionPolicyStrings.ReliableSession11Prefix;
string exceptionString = (node == null)
? SR.GetString(SR.ElementRequired, wsrmPrefix,
ReliableSessionPolicyStrings.ReliableSessionName, MetadataStrings.WSPolicy.Prefix,
MetadataStrings.WSPolicy.Elements.Policy)
: SR.GetString(SR.ElementFound, wsrmPrefix,
ReliableSessionPolicyStrings.ReliableSessionName, MetadataStrings.WSPolicy.Prefix,
MetadataStrings.WSPolicy.Elements.Policy, node.LocalName, node.NamespaceURI);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(exceptionString));
}
return (XmlElement)node;
}
class Wsrm11PolicyAlternative
{
bool hasValidPolicy = true;
bool isOrdered = false;
public bool HasValidPolicy
{
get
{
return this.hasValidPolicy;
}
}
public static Wsrm11PolicyAlternative ImportAlternative(MetadataImporter importer,
IEnumerable<XmlElement> alternative)
{
State state = State.Security;
Wsrm11PolicyAlternative wsrmPolicy = new Wsrm11PolicyAlternative();
foreach (XmlElement node in alternative)
{
if (state == State.Security)
{
state = State.DeliveryAssurance;
if (wsrmPolicy.TryImportSequenceSTR(node))
{
continue;
}
}
if (state == State.DeliveryAssurance)
{
state = State.Done;
if (wsrmPolicy.TryImportDeliveryAssurance(importer, node))
{
continue;
}
}
string exceptionString = SR.GetString(SR.UnexpectedXmlChildNode,
node.LocalName,
node.NodeType,
ReliableSessionPolicyStrings.ReliableSessionName);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(exceptionString));
}
return wsrmPolicy;
}
public static void ThrowInvalidBindingException()
{
string exceptionString = SR.GetString(SR.AssertionNotSupported,
ReliableSessionPolicyStrings.ReliableSession11Prefix,
ReliableSessionPolicyStrings.SequenceTransportSecurity);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(exceptionString));
}
public void TransferSettings(ReliableSessionBindingElement settings)
{
settings.Ordered = this.isOrdered;
}
bool TryImportSequenceSTR(XmlElement node)
{
string wsrmNs = ReliableSessionPolicyStrings.ReliableSession11Namespace;
if (IsElement(node, wsrmNs, ReliableSessionPolicyStrings.SequenceSTR))
{
return true;
}
if (IsElement(node, wsrmNs, ReliableSessionPolicyStrings.SequenceTransportSecurity))
{
this.hasValidPolicy = false;
return true;
}
return false;
}
bool TryImportDeliveryAssurance(MetadataImporter importer, XmlElement node)
{
string wsrmNs = ReliableSessionPolicyStrings.ReliableSession11Namespace;
if (!IsElement(node, wsrmNs, ReliableSessionPolicyStrings.DeliveryAssurance))
{
return false;
}
// Policy
IEnumerator policyNodes = node.ChildNodes.GetEnumerator();
XmlNode policyNode = SkipToNode(policyNodes);
XmlElement policyElement = ThrowIfNotPolicyElement(policyNode, ReliableMessagingVersion.WSReliableMessaging11);
IEnumerable<IEnumerable<XmlElement>> alternatives = importer.NormalizePolicy(new XmlElement[] { policyElement });
foreach (IEnumerable<XmlElement> alternative in alternatives)
{
State state = State.Assurance;
foreach (XmlElement element in alternative)
{
if (state == State.Assurance)
{
state = State.Order;
if (!IsElement(element, wsrmNs, ReliableSessionPolicyStrings.ExactlyOnce)
&& !IsElement(element, wsrmNs, ReliableSessionPolicyStrings.AtMostOnce)
&& !IsElement(element, wsrmNs, ReliableSessionPolicyStrings.AtMostOnce))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
SR.DeliveryAssuranceRequired,
wsrmNs,
element.LocalName,
element.NamespaceURI)));
}
// Found required DeliveryAssurance, ignore the value and skip to InOrder
continue;
}
if (state == State.Order)
{
state = State.Done;
// InOrder
if (IsElement(element, wsrmNs, ReliableSessionPolicyStrings.InOrder))
{
// set ordered
if (!this.isOrdered)
{
this.isOrdered = true;
}
continue;
}
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
SR.UnexpectedXmlChildNode,
element.LocalName,
element.NodeType,
ReliableSessionPolicyStrings.DeliveryAssurance)));
}
if (state == State.Assurance)
{
string exceptionString = SR.GetString(SR.DeliveryAssuranceRequiredNothingFound, wsrmNs);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(exceptionString));
}
}
policyNode = SkipToNode(policyNodes);
if (policyNode != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
SR.UnexpectedXmlChildNode,
policyNode.LocalName,
policyNode.NodeType,
node.LocalName)));
}
return true;
}
}
enum State
{
Security,
DeliveryAssurance,
Assurance,
Order,
InactivityTimeout,
AcknowledgementInterval,
Done,
}
}
}
|