e79aa3c0ed
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
343 lines
12 KiB
C#
343 lines
12 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Runtime.Serialization;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Security;
|
|
using System.Xml;
|
|
|
|
public sealed class OneWayBindingElement : BindingElement,
|
|
IPolicyExportExtension
|
|
{
|
|
ChannelPoolSettings channelPoolSettings;
|
|
bool packetRoutable;
|
|
int maxAcceptedChannels;
|
|
|
|
public OneWayBindingElement()
|
|
{
|
|
this.channelPoolSettings = new ChannelPoolSettings();
|
|
this.packetRoutable = OneWayDefaults.PacketRoutable;
|
|
this.maxAcceptedChannels = OneWayDefaults.MaxAcceptedChannels;
|
|
}
|
|
|
|
OneWayBindingElement(OneWayBindingElement elementToBeCloned)
|
|
: base(elementToBeCloned)
|
|
{
|
|
this.channelPoolSettings = elementToBeCloned.ChannelPoolSettings.Clone();
|
|
this.packetRoutable = elementToBeCloned.PacketRoutable;
|
|
this.maxAcceptedChannels = elementToBeCloned.maxAcceptedChannels;
|
|
}
|
|
|
|
public ChannelPoolSettings ChannelPoolSettings
|
|
{
|
|
get
|
|
{
|
|
return this.channelPoolSettings;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
|
|
this.channelPoolSettings = value;
|
|
}
|
|
}
|
|
|
|
// server
|
|
[DefaultValue(OneWayDefaults.MaxAcceptedChannels)]
|
|
public int MaxAcceptedChannels
|
|
{
|
|
get
|
|
{
|
|
return this.maxAcceptedChannels;
|
|
}
|
|
set
|
|
{
|
|
if (value <= 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.ValueMustBePositive)));
|
|
|
|
this.maxAcceptedChannels = value;
|
|
}
|
|
}
|
|
|
|
[DefaultValue(OneWayDefaults.PacketRoutable)]
|
|
public bool PacketRoutable
|
|
{
|
|
get
|
|
{
|
|
return this.packetRoutable;
|
|
}
|
|
|
|
set
|
|
{
|
|
this.packetRoutable = value;
|
|
}
|
|
}
|
|
|
|
public override BindingElement Clone()
|
|
{
|
|
return new OneWayBindingElement(this);
|
|
}
|
|
|
|
public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
if (typeof(TChannel) != typeof(IOutputChannel))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel",
|
|
SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
|
|
}
|
|
|
|
// Prefer IDuplexChannel
|
|
if (context.CanBuildInnerChannelFactory<IDuplexChannel>())
|
|
{
|
|
return (IChannelFactory<TChannel>)(object)new DuplexOneWayChannelFactory(this, context);
|
|
}
|
|
|
|
// Prefer IDuplexSessionChannel
|
|
if (context.CanBuildInnerChannelFactory<IDuplexSessionChannel>())
|
|
{
|
|
return (IChannelFactory<TChannel>)(object)new DuplexSessionOneWayChannelFactory(this, context);
|
|
}
|
|
|
|
// Followed by IRequestChannel
|
|
if (context.CanBuildInnerChannelFactory<IRequestChannel>())
|
|
{
|
|
return (IChannelFactory<TChannel>)(object)new RequestOneWayChannelFactory(this, context);
|
|
}
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
#pragma warning suppress 56506 // context.Binding will never be null.
|
|
new InvalidOperationException(SR.GetString(SR.OneWayInternalTypeNotSupported, context.Binding.Name)));
|
|
}
|
|
|
|
public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
if (typeof(TChannel) != typeof(IInputChannel))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel",
|
|
SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
|
|
}
|
|
|
|
// Prefer IDuplexChannel
|
|
if (context.CanBuildInnerChannelListener<IDuplexChannel>())
|
|
{
|
|
return (IChannelListener<TChannel>)(object)new DuplexOneWayChannelListener(this, context);
|
|
}
|
|
|
|
// Prefer IDuplexSessionChannel
|
|
if (context.CanBuildInnerChannelListener<IDuplexSessionChannel>())
|
|
{
|
|
return (IChannelListener<TChannel>)(object)new DuplexSessionOneWayChannelListener(this, context);
|
|
}
|
|
|
|
// Followed by IRequestChannel
|
|
if (context.CanBuildInnerChannelListener<IReplyChannel>())
|
|
{
|
|
return (IChannelListener<TChannel>)(object)new ReplyOneWayChannelListener(this, context);
|
|
}
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
#pragma warning suppress 56506 // context.Binding will never be null.
|
|
new InvalidOperationException(SR.GetString(SR.OneWayInternalTypeNotSupported, context.Binding.Name)));
|
|
}
|
|
|
|
public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
if (typeof(TChannel) != typeof(IOutputChannel))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// we can convert IDuplexChannel
|
|
if (context.CanBuildInnerChannelFactory<IDuplexChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// we can convert IDuplexSessionChannel
|
|
if (context.CanBuildInnerChannelFactory<IDuplexSessionChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// and also IRequestChannel
|
|
if (context.CanBuildInnerChannelFactory<IRequestChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool CanBuildChannelListener<TChannel>(BindingContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
if (typeof(TChannel) != typeof(IInputChannel))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// we can convert IDuplexChannel
|
|
if (context.CanBuildInnerChannelListener<IDuplexChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// we can convert IDuplexSessionChannel
|
|
if (context.CanBuildInnerChannelListener<IDuplexSessionChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// and also IRequestChannel
|
|
if (context.CanBuildInnerChannelListener<IReplyChannel>())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static MessagePartSpecification oneWaySignedMessageParts;
|
|
|
|
static MessagePartSpecification OneWaySignedMessageParts
|
|
{
|
|
get
|
|
{
|
|
if (oneWaySignedMessageParts == null)
|
|
{
|
|
MessagePartSpecification tempSignedMessageParts = new MessagePartSpecification(
|
|
new XmlQualifiedName(DotNetOneWayStrings.HeaderName, DotNetOneWayStrings.Namespace)
|
|
);
|
|
tempSignedMessageParts.MakeReadOnly();
|
|
oneWaySignedMessageParts = tempSignedMessageParts;
|
|
}
|
|
|
|
return oneWaySignedMessageParts;
|
|
}
|
|
}
|
|
|
|
public override T GetProperty<T>(BindingContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
// make sure our Datagram header is signed
|
|
if (typeof(T) == typeof(ChannelProtectionRequirements))
|
|
{
|
|
ChannelProtectionRequirements myRequirements = new ChannelProtectionRequirements();
|
|
if (PacketRoutable)
|
|
{
|
|
myRequirements.IncomingSignatureParts.AddParts(OneWaySignedMessageParts);
|
|
myRequirements.OutgoingSignatureParts.AddParts(OneWaySignedMessageParts);
|
|
}
|
|
ChannelProtectionRequirements innerRequirements = context.GetInnerProperty<ChannelProtectionRequirements>();
|
|
if (innerRequirements != null)
|
|
{
|
|
myRequirements.Add(innerRequirements);
|
|
}
|
|
return (T)(object)myRequirements;
|
|
}
|
|
else
|
|
{
|
|
return context.GetInnerProperty<T>();
|
|
}
|
|
}
|
|
|
|
internal override bool IsMatch(BindingElement b)
|
|
{
|
|
if (b == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
OneWayBindingElement oneWayBindingElement = b as OneWayBindingElement;
|
|
if (oneWayBindingElement == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!this.channelPoolSettings.IsMatch(oneWayBindingElement.ChannelPoolSettings))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (this.packetRoutable != oneWayBindingElement.PacketRoutable)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (this.maxAcceptedChannels != oneWayBindingElement.MaxAcceptedChannels)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
|
|
}
|
|
|
|
if (context.BindingElements != null)
|
|
{
|
|
OneWayBindingElement oneWay = context.BindingElements.Find<OneWayBindingElement>();
|
|
|
|
if (oneWay != null)
|
|
{
|
|
// base assertion
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlElement assertion = doc.CreateElement(OneWayPolicyConstants.Prefix,
|
|
OneWayPolicyConstants.OneWay, OneWayPolicyConstants.Namespace);
|
|
|
|
if (oneWay.PacketRoutable)
|
|
{
|
|
// add nested packet routable assertion
|
|
XmlElement child = doc.CreateElement(OneWayPolicyConstants.Prefix, OneWayPolicyConstants.PacketRoutable, OneWayPolicyConstants.Namespace);
|
|
assertion.AppendChild(child);
|
|
}
|
|
|
|
context.GetBindingAssertions().Add(assertion);
|
|
}
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Never)]
|
|
public bool ShouldSerializeChannelPoolSettings()
|
|
{
|
|
return this.channelPoolSettings.InternalShouldSerialize();
|
|
}
|
|
}
|
|
}
|