Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

386 lines
15 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.ObjectModel;
using System.Net;
using System.Net.Security;
using System.ServiceModel.Description;
using System.ServiceModel;
using System.ServiceModel.PeerResolvers;
using System.Xml;
static class PeerTransportPolicyConstants
{
public const string PeerTransportSecurityMode = "PeerTransportSecurityMode";
public const string PeerTransportCredentialType = "PeerTransportCredentialType";
public const string PeerTransportCredentialTypePassword = "PeerTransportCredentialTypePassword";
public const string PeerTransportCredentialTypeCertificate = "PeerTransportCredentialTypeCertificate";
public const string PeerTransportSecurityModeNone = "PeerTransportSecurityModeNone";
public const string PeerTransportSecurityModeTransport = "PeerTransportSecurityModeTransport";
public const string PeerTransportSecurityModeMessage = "PeerTransportSecurityModeMessage";
public const string PeerTransportSecurityModeTransportWithMessageCredential = "PeerTransportSecurityModeTransportWithMessageCredential";
public const string PeerTransportPrefix = "pc";
}
[ObsoleteAttribute ("PeerChannel feature is obsolete and will be removed in the future.", false)]
public sealed class PeerTransportBindingElement
: TransportBindingElement, IWsdlExportExtension, ITransportPolicyImport, IPolicyExportExtension
{
IPAddress listenIPAddress;
int port;
PeerResolver resolver;
bool resolverSet;
PeerSecuritySettings peerSecurity;
public PeerTransportBindingElement()
: base()
{
this.listenIPAddress = PeerTransportDefaults.ListenIPAddress;
this.port = PeerTransportDefaults.Port;
if (PeerTransportDefaults.ResolverAvailable)
{
this.resolver = PeerTransportDefaults.CreateResolver();
}
peerSecurity = new PeerSecuritySettings();
}
PeerTransportBindingElement(PeerTransportBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
this.listenIPAddress = elementToBeCloned.listenIPAddress;
this.port = elementToBeCloned.port;
this.resolverSet = elementToBeCloned.resolverSet;
this.resolver = elementToBeCloned.resolver;
peerSecurity = new PeerSecuritySettings(elementToBeCloned.Security);
}
public IPAddress ListenIPAddress
{
get
{
return this.listenIPAddress;
}
set
{
PeerValidateHelper.ValidateListenIPAddress(value);
this.listenIPAddress = value;
}
}
public override long MaxReceivedMessageSize
{
get
{
return base.MaxReceivedMessageSize;
}
set
{
PeerValidateHelper.ValidateMaxMessageSize(value);
base.MaxReceivedMessageSize = value;
}
}
public int Port
{
get
{
return this.port;
}
set
{
PeerValidateHelper.ValidatePort(value);
this.port = value;
}
}
internal PeerResolver Resolver
{
get
{
return this.resolver;
}
set
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
}
if (value.GetType() == PeerTransportDefaults.ResolverType)
{
if (!PeerTransportDefaults.ResolverInstalled)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("value", SR.GetString(SR.PeerPnrpNotInstalled));
}
else if (!PeerTransportDefaults.ResolverAvailable)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("value", SR.GetString(SR.PeerPnrpNotAvailable));
}
}
this.resolver = value;
this.resolverSet = true;
}
}
public override string Scheme { get { return PeerStrings.Scheme; } }
public PeerSecuritySettings Security
{
get { return peerSecurity; }
}
void ITransportPolicyImport.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
{
if (importer == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("importer");
if (context == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
peerSecurity.OnImportPolicy(importer, context);
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
peerSecurity.OnExportPolicy(exporter, context);
bool createdNew;
MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(context.BindingElements, out createdNew);
if (createdNew && encodingBindingElement is IPolicyExportExtension)
{
((IPolicyExportExtension)encodingBindingElement).ExportPolicy(exporter, context);
}
WsdlExporter.WSAddressingHelper.AddWSAddressingAssertion(exporter, context, encodingBindingElement.MessageVersion.Addressing);
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context) { }
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext)
{
bool createdNew;
MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(endpointContext, out createdNew);
TransportBindingElement.ExportWsdlEndpoint(
exporter, endpointContext, TransportPolicyConstants.PeerTransportUri,
encodingBindingElement.MessageVersion.Addressing);
}
internal void CreateDefaultResolver(PeerResolverSettings settings)
{
if (PeerTransportDefaults.ResolverAvailable)
{
this.resolver = new PnrpPeerResolver(settings.ReferralPolicy);
}
}
MessageEncodingBindingElement FindMessageEncodingBindingElement(BindingElementCollection bindingElements, out bool createdNew)
{
createdNew = false;
MessageEncodingBindingElement encodingBindingElement = bindingElements.Find<MessageEncodingBindingElement>();
if (encodingBindingElement == null)
{
createdNew = true;
encodingBindingElement = new BinaryMessageEncodingBindingElement();
}
return encodingBindingElement;
}
MessageEncodingBindingElement FindMessageEncodingBindingElement(WsdlEndpointConversionContext endpointContext, out bool createdNew)
{
BindingElementCollection bindingElements = endpointContext.Endpoint.Binding.CreateBindingElements();
return FindMessageEncodingBindingElement(bindingElements, out createdNew);
}
public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("context"));
}
if (!this.CanBuildChannelFactory<TChannel>(context))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel", SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
}
if (this.ManualAddressing)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ManualAddressingNotSupported)));
}
PeerResolver peerResolver = GetResolver(context);
return new PeerChannelFactory<TChannel>(this, context, peerResolver);
}
public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
PeerChannelListenerBase peerListener = null;
PeerResolver peerResolver = GetResolver(context);
if (typeof(TChannel) == typeof(IInputChannel))
{
peerListener = new PeerInputChannelListener(this, context, peerResolver);
}
else if (typeof(TChannel) == typeof(IDuplexChannel))
{
peerListener = new PeerDuplexChannelListener(this, context, peerResolver);
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("TChannel", SR.GetString(SR.ChannelTypeNotSupported, typeof(TChannel)));
}
return (IChannelListener<TChannel>)peerListener;
}
public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
{
return (typeof(TChannel) == typeof(IOutputChannel)
|| typeof(TChannel) == typeof(IDuplexChannel));
}
public override bool CanBuildChannelListener<TChannel>(BindingContext context)
{
return (typeof(TChannel) == typeof(IInputChannel)
|| typeof(TChannel) == typeof(IDuplexChannel));
}
public override BindingElement Clone()
{
return new PeerTransportBindingElement(this);
}
public override T GetProperty<T>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (typeof(T) == typeof(IBindingMulticastCapabilities))
{
return (T)(object)new BindingMulticastCapabilities();
}
else if (typeof(T) == typeof(ISecurityCapabilities))
{
return (T)(object)new SecurityCapabilities(Security.SupportsAuthentication, Security.SupportsAuthentication,
false, Security.SupportedProtectionLevel, Security.SupportedProtectionLevel);
}
else if (typeof(T) == typeof(IBindingDeliveryCapabilities))
{
return (T)(object)new BindingDeliveryCapabilitiesHelper();
}
return base.GetProperty<T>(context);
}
// Return the resolver member (if set) or create one from the resolver binding element in the context
PeerResolver GetResolver(BindingContext context)
{
if (this.resolverSet)
{
return this.resolver;
}
Collection<PeerCustomResolverBindingElement> customResolverElements
= context.BindingParameters.FindAll<PeerCustomResolverBindingElement>();
if (customResolverElements.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MultiplePeerCustomResolverBindingElementsInParameters)));
}
else if (customResolverElements.Count == 1)
{
context.BindingParameters.Remove<PeerCustomResolverBindingElement>();
return customResolverElements[0].CreatePeerResolver();
}
// If resolver binding element is included in the context, use it to create the resolver. elementToBeClonedwise,
// if default resolver is available, use it.
Collection<PeerResolverBindingElement> resolverBindingElements
= context.BindingParameters.FindAll<PeerResolverBindingElement>();
if (resolverBindingElements.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MultiplePeerResolverBindingElementsinParameters)));
}
else if (resolverBindingElements.Count == 0)
{
if (this.resolver != null) // default resolver available?
{
return this.resolver;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.GetString(SR.PeerResolverBindingElementRequired, context.Binding.Name)));
}
}
else if (resolverBindingElements[0].GetType() == PeerTransportDefaults.ResolverBindingElementType)
{
if (!PeerTransportDefaults.ResolverInstalled)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.GetString(SR.PeerPnrpNotInstalled)));
}
else if (!PeerTransportDefaults.ResolverAvailable)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.GetString(SR.PeerPnrpNotAvailable)));
}
}
context.BindingParameters.Remove<PeerResolverBindingElement>();
return resolverBindingElements[0].CreatePeerResolver();
}
class BindingMulticastCapabilities : IBindingMulticastCapabilities
{
public bool IsMulticast { get { return true; } }
}
class BindingDeliveryCapabilitiesHelper : IBindingDeliveryCapabilities
{
internal BindingDeliveryCapabilitiesHelper()
{
}
bool IBindingDeliveryCapabilities.AssuresOrderedDelivery
{
get { return false; }
}
bool IBindingDeliveryCapabilities.QueuedDelivery
{
get { return false; }
}
}
}
}