public override IChannelListener <TChannel> BuildChannelListener <TChannel>(BindingContext context)
{
return(default(IChannelListener <TChannel>));
}
public virtual bool CanBuildChannelFactory <TChannel>(BindingParameterCollection parameters)
{
BindingContext context = new BindingContext(new CustomBinding(this), parameters);
return(context.CanBuildInnerChannelFactory <TChannel>());
}
public override IChannelListener <TChannel> BuildChannelListener <TChannel> (BindingContext context)
{
throw new NotImplementedException();
}
protected TransportChannelListener(TransportBindingElement bindingElement, BindingContext context)
: this(bindingElement, context, TransportDefaults.GetDefaultMessageEncoderFactory())
{
}
protected TransportChannelListener(TransportBindingElement bindingElement, BindingContext context,
MessageEncoderFactory defaultMessageEncoderFactory, HostNameComparisonMode hostNameComparisonMode)
: base(context.Binding)
{
HostNameComparisonModeHelper.Validate(hostNameComparisonMode);
this.hostNameComparisonMode = hostNameComparisonMode;
this.manualAddressing = bindingElement.ManualAddressing;
this.maxBufferPoolSize = bindingElement.MaxBufferPoolSize;
this.maxReceivedMessageSize = bindingElement.MaxReceivedMessageSize;
Collection <MessageEncodingBindingElement> messageEncoderBindingElements
= context.BindingParameters.FindAll <MessageEncodingBindingElement>();
if (messageEncoderBindingElements.Count > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MultipleMebesInParameters)));
}
else if (messageEncoderBindingElements.Count == 1)
{
this.messageEncoderFactory = messageEncoderBindingElements[0].CreateMessageEncoderFactory();
context.BindingParameters.Remove <MessageEncodingBindingElement>();
}
else
{
this.messageEncoderFactory = defaultMessageEncoderFactory;
}
if (null != this.messageEncoderFactory)
{
this.messageVersion = this.messageEncoderFactory.MessageVersion;
}
else
{
this.messageVersion = MessageVersion.None;
}
ServiceSecurityAuditBehavior auditBehavior = context.BindingParameters.Find <ServiceSecurityAuditBehavior>();
if (auditBehavior != null)
{
this.auditBehavior = auditBehavior.Clone();
}
else
{
this.auditBehavior = new ServiceSecurityAuditBehavior();
}
if ((context.ListenUriMode == ListenUriMode.Unique) && (context.ListenUriBaseAddress == null))
{
UriBuilder uriBuilder = new UriBuilder(this.Scheme, DnsCache.MachineName);
uriBuilder.Path = this.GeneratedAddressPrefix;
context.ListenUriBaseAddress = uriBuilder.Uri;
}
UriSchemeKeyedCollection.ValidateBaseAddress(context.ListenUriBaseAddress, "baseAddress");
if (context.ListenUriBaseAddress.Scheme != this.Scheme)
{
// URI schemes are case-insensitive, so try a case insensitive compare now
if (string.Compare(context.ListenUriBaseAddress.Scheme, this.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
"context.ListenUriBaseAddress",
SR.GetString(SR.InvalidUriScheme, context.ListenUriBaseAddress.Scheme, this.Scheme));
}
}
Fx.Assert(context.ListenUriRelativeAddress != null, ""); // validated by BindingContext
if (context.ListenUriMode == ListenUriMode.Explicit)
{
this.SetUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress);
}
else // ListenUriMode.Unique:
{
string relativeAddress = context.ListenUriRelativeAddress;
if (relativeAddress.Length > 0 && !relativeAddress.EndsWith("/", StringComparison.Ordinal))
{
relativeAddress += "/";
}
this.SetUri(context.ListenUriBaseAddress, relativeAddress + Guid.NewGuid().ToString());
}
this.transportManagerContainer = new TransportManagerContainer(this);
}
BuildChannelListenerCore <TChannel> (BindingContext context)
where TChannel : class, IChannel;
protected ReliableListenerOverReply(ReliableSessionBindingElement binding, BindingContext context) : base(binding, context)
{
base.FaultHelper = new ReplyFaultHelper(context.Binding.SendTimeout, context.Binding.CloseTimeout);
}
protected override IChannelFactory <TChannel> BuildChannelFactoryCore <TChannel>(BindingContext context)
{
ISecurityCapabilities securityCapabilities = GetProperty <ISecurityCapabilities>(context);
SecurityCredentialsManager credentialsManager = context.BindingParameters.Find <SecurityCredentialsManager>();
if (credentialsManager == null)
{
credentialsManager = ClientCredentials.CreateDefaultCredentials();
}
SecureConversationSecurityTokenParameters scParameters = null;
if (EndpointSupportingTokenParameters.Endorsing.Count > 0)
{
scParameters = EndpointSupportingTokenParameters.Endorsing[0] as SecureConversationSecurityTokenParameters;
}
// This adds the demuxer element to the context
bool requireDemuxer = RequiresChannelDemuxer();
ChannelBuilder channelBuilder = new ChannelBuilder(context, requireDemuxer);
if (requireDemuxer)
{
ApplyPropertiesOnDemuxer(channelBuilder, context);
}
BindingContext issuerBindingContext = context.Clone();
SecurityChannelFactory <TChannel> channelFactory;
if (scParameters != null)
{
if (scParameters.BootstrapSecurityBindingElement == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SecureConversationSecurityTokenParametersRequireBootstrapBinding));
}
scParameters.IssuerBindingContext = issuerBindingContext;
if (scParameters.RequireCancellation)
{
SessionSymmetricTransportSecurityProtocolFactory sessionFactory = new SessionSymmetricTransportSecurityProtocolFactory();
sessionFactory.SecurityTokenParameters = scParameters.Clone();
((SecureConversationSecurityTokenParameters)sessionFactory.SecurityTokenParameters).IssuerBindingContext = issuerBindingContext;
EndpointSupportingTokenParameters.Endorsing.RemoveAt(0);
try
{
base.ConfigureProtocolFactory(sessionFactory, credentialsManager, false, issuerBindingContext, context.Binding);
}
finally
{
EndpointSupportingTokenParameters.Endorsing.Insert(0, scParameters);
}
SecuritySessionClientSettings <TChannel> sessionClientSettings = new SecuritySessionClientSettings <TChannel>();
sessionClientSettings.ChannelBuilder = channelBuilder;
sessionClientSettings.KeyRenewalInterval = LocalClientSettings.SessionKeyRenewalInterval;
sessionClientSettings.KeyRolloverInterval = LocalClientSettings.SessionKeyRolloverInterval;
sessionClientSettings.TolerateTransportFailures = LocalClientSettings.ReconnectTransportOnFailure;
sessionClientSettings.CanRenewSession = scParameters.CanRenewSession;
sessionClientSettings.IssuedSecurityTokenParameters = scParameters.Clone();
((SecureConversationSecurityTokenParameters)sessionClientSettings.IssuedSecurityTokenParameters).IssuerBindingContext = issuerBindingContext;
sessionClientSettings.SecurityStandardsManager = sessionFactory.StandardsManager;
sessionClientSettings.SessionProtocolFactory = sessionFactory;
channelFactory = new SecurityChannelFactory <TChannel>(securityCapabilities, context, sessionClientSettings);
}
else
{
TransportSecurityProtocolFactory protocolFactory = new TransportSecurityProtocolFactory();
EndpointSupportingTokenParameters.Endorsing.RemoveAt(0);
try
{
base.ConfigureProtocolFactory(protocolFactory, credentialsManager, false, issuerBindingContext, context.Binding);
SecureConversationSecurityTokenParameters acceleratedTokenParameters = (SecureConversationSecurityTokenParameters)scParameters.Clone();
acceleratedTokenParameters.IssuerBindingContext = issuerBindingContext;
protocolFactory.SecurityBindingElement.EndpointSupportingTokenParameters.Endorsing.Insert(0, acceleratedTokenParameters);
}
finally
{
EndpointSupportingTokenParameters.Endorsing.Insert(0, scParameters);
}
channelFactory = new SecurityChannelFactory <TChannel>(securityCapabilities, context, channelBuilder, protocolFactory);
}
}
else
{
SecurityProtocolFactory protocolFactory = CreateSecurityProtocolFactory <TChannel>(
context, credentialsManager, false, issuerBindingContext);
channelFactory = new SecurityChannelFactory <TChannel>(securityCapabilities, context, channelBuilder, protocolFactory);
}
return(channelFactory);
}
internal HttpsChannelFactory(HttpsTransportBindingElement httpsBindingElement, BindingContext context)
: base(httpsBindingElement, context)
{
RequireClientCertificate = httpsBindingElement.RequireClientCertificate;
ClientCredentials credentials = context.BindingParameters.Find <ClientCredentials>();
if (credentials != null && credentials.ServiceCertificate.SslCertificateAuthentication != null)
{
_sslCertificateValidator = credentials.ServiceCertificate.SslCertificateAuthentication.GetCertificateValidator();
_remoteCertificateValidationCallback = RemoteCertificateValidationCallback;
}
}
public abstract T GetProperty <T>(BindingContext context) where T : class;
internal override SecurityProtocolFactory CreateSecurityProtocolFactory <TChannel>(BindingContext context, SecurityCredentialsManager credentialsManager, bool isForService, BindingContext issuerBindingContext)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(context));
}
if (credentialsManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(credentialsManager));
}
TransportSecurityProtocolFactory protocolFactory = new TransportSecurityProtocolFactory();
base.ConfigureProtocolFactory(protocolFactory, credentialsManager, isForService, issuerBindingContext, context.Binding);
protocolFactory.DetectReplays = false;
return(protocolFactory);
}
public override T GetProperty <T>(BindingContext context)
{
return(default(T));
}
public override bool CanBuildChannelListener <TChannel>(BindingContext context)
{
return(default(bool));
}
public override bool CanBuildChannelFactory <TChannel>(BindingContext context)
{
return(default(bool));
}
BuildChannelFactoryCore <TChannel> (BindingContext context);
public SecurityChannelFactory(ISecurityCapabilities securityCapabilities, BindingContext context, ChannelBuilder channelBuilder, SecurityProtocolFactory protocolFactory, IChannelFactory innerChannelFactory)
: this(securityCapabilities, context, channelBuilder, innerChannelFactory)
{
this.securityProtocolFactory = protocolFactory;
}
public override IChannelListener <TChannel> BuildChannelListener <TChannel> (
BindingContext context)
{
return(BuildChannelListenerCore <TChannel> (context));
}
public SecurityChannelFactory(ISecurityCapabilities securityCapabilities, BindingContext context, SecuritySessionClientSettings <TChannel> sessionClientSettings)
: this(securityCapabilities, context, sessionClientSettings.ChannelBuilder, sessionClientSettings.CreateInnerChannelFactory())
{
this.sessionMode = true;
this.sessionClientSettings = sessionClientSettings;
}
public override T GetProperty <T> (BindingContext context)
{
return(null);
}
public SecurityChannelFactory(ISecurityCapabilities securityCapabilities, BindingContext context, ChannelBuilder channelBuilder, SecurityProtocolFactory protocolFactory)
: this(securityCapabilities, context, channelBuilder, protocolFactory, (IChannelFactory)channelBuilder.BuildChannelFactory <TChannel>())
{
}
public AspNetChannelListener(HttpTransportBindingElement source,
BindingContext context)
: base(source, context)
{
}
public override T GetProperty <T>(BindingContext context)
{
throw new NotImplementedException();
}
protected TransportChannelListener(TransportBindingElement bindingElement, BindingContext context,
HostNameComparisonMode hostNameComparisonMode)
: this(bindingElement, context, TransportDefaults.GetDefaultMessageEncoderFactory(), hostNameComparisonMode)
{
}
internal HttpsChannelFactory(HttpsTransportBindingElement httpsBindingElement, BindingContext context)
: base(httpsBindingElement, context)
{
_requireClientCertificate = httpsBindingElement.RequireClientCertificate;
ClientCredentials credentials = context.BindingParameters.Find <ClientCredentials>();
}
public bool CanBuildInnerChannelFactory <TChannel>()
{
BindingContext clone = this.Clone();
return(clone.RemoveNextElement().CanBuildChannelFactory <TChannel>(clone));
}
public DuplexChannelDemuxer(BindingContext context) : base(context)
{
}
public static ServiceChannelFactory BuildChannelFactory(ServiceEndpoint serviceEndpoint, bool useActiveAutoClose)
{
if (serviceEndpoint == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceEndpoint");
}
serviceEndpoint.EnsureInvariants();
serviceEndpoint.ValidateForClient();
ChannelRequirements requirements;
ContractDescription contractDescription = serviceEndpoint.Contract;
ChannelRequirements.ComputeContractRequirements(contractDescription, out requirements);
BindingParameterCollection parameters;
ClientRuntime clientRuntime = DispatcherBuilder.BuildProxyBehavior(serviceEndpoint, out parameters);
Binding binding = serviceEndpoint.Binding;
Type[] requiredChannels = ChannelRequirements.ComputeRequiredChannels(ref requirements);
CustomBinding customBinding = new CustomBinding(binding);
BindingContext context = new BindingContext(customBinding, parameters);
customBinding = new CustomBinding(context.RemainingBindingElements);
customBinding.CopyTimeouts(serviceEndpoint.Binding);
foreach (Type type in requiredChannels)
{
if (type == typeof(IOutputChannel) && customBinding.CanBuildChannelFactory <IOutputChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutput(customBinding.BuildChannelFactory <IOutputChannel>(parameters), clientRuntime, binding));
}
if (type == typeof(IRequestChannel) && customBinding.CanBuildChannelFactory <IRequestChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequest(customBinding.BuildChannelFactory <IRequestChannel>(parameters), clientRuntime, binding));
}
if (type == typeof(IDuplexChannel) && customBinding.CanBuildChannelFactory <IDuplexChannel>(parameters))
{
if (requirements.usesReply &&
binding.CreateBindingElements().Find <TransportBindingElement>().ManualAddressing)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.CantCreateChannelWithManualAddressing));
}
return(new ServiceChannelFactoryOverDuplex(customBinding.BuildChannelFactory <IDuplexChannel>(parameters), clientRuntime, binding));
}
if (type == typeof(IOutputSessionChannel) && customBinding.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutputSession(customBinding.BuildChannelFactory <IOutputSessionChannel>(parameters), clientRuntime, binding, false));
}
if (type == typeof(IRequestSessionChannel) && customBinding.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequestSession(customBinding.BuildChannelFactory <IRequestSessionChannel>(parameters), clientRuntime, binding, false));
}
if (type == typeof(IDuplexSessionChannel) && customBinding.CanBuildChannelFactory <IDuplexSessionChannel>(parameters))
{
if (requirements.usesReply &&
binding.CreateBindingElements().Find <TransportBindingElement>().ManualAddressing)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.CantCreateChannelWithManualAddressing));
}
return(new ServiceChannelFactoryOverDuplexSession(customBinding.BuildChannelFactory <IDuplexSessionChannel>(parameters), clientRuntime, binding, useActiveAutoClose));
}
}
foreach (Type type in requiredChannels)
{
// For SessionMode.Allowed or SessionMode.NotAllowed we will accept session-ful variants as well
if (type == typeof(IOutputChannel) && customBinding.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverOutputSession(customBinding.BuildChannelFactory <IOutputSessionChannel>(parameters), clientRuntime, binding, true));
}
if (type == typeof(IRequestChannel) && customBinding.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
return(new ServiceChannelFactoryOverRequestSession(customBinding.BuildChannelFactory <IRequestSessionChannel>(parameters), clientRuntime, binding, true));
}
// and for SessionMode.Required, it is possible that the InstanceContextProvider is handling the session management, so
// accept datagram variants if that is the case
if (type == typeof(IRequestSessionChannel) && customBinding.CanBuildChannelFactory <IRequestChannel>(parameters) &&
customBinding.GetProperty <IContextSessionProvider>(parameters) != null)
{
return(new ServiceChannelFactoryOverRequest(customBinding.BuildChannelFactory <IRequestChannel>(parameters), clientRuntime, binding));
}
}
// we put a lot of work into creating a good error message, as this is a common case
Dictionary <Type, byte> supportedChannels = new Dictionary <Type, byte>();
if (customBinding.CanBuildChannelFactory <IOutputChannel>(parameters))
{
supportedChannels.Add(typeof(IOutputChannel), 0);
}
if (customBinding.CanBuildChannelFactory <IRequestChannel>(parameters))
{
supportedChannels.Add(typeof(IRequestChannel), 0);
}
if (customBinding.CanBuildChannelFactory <IDuplexChannel>(parameters))
{
supportedChannels.Add(typeof(IDuplexChannel), 0);
}
if (customBinding.CanBuildChannelFactory <IOutputSessionChannel>(parameters))
{
supportedChannels.Add(typeof(IOutputSessionChannel), 0);
}
if (customBinding.CanBuildChannelFactory <IRequestSessionChannel>(parameters))
{
supportedChannels.Add(typeof(IRequestSessionChannel), 0);
}
if (customBinding.CanBuildChannelFactory <IDuplexSessionChannel>(parameters))
{
supportedChannels.Add(typeof(IDuplexSessionChannel), 0);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ChannelRequirements.CantCreateChannelException(
supportedChannels.Keys, requiredChannels, binding.Name));
}
public override IChannelFactory <TChannel> BuildChannelFactory <TChannel> (
BindingContext context)
{
return(BuildChannelFactoryCore <TChannel> (context));
}
public override bool CanBuildChannelFactory <TChannel>(BindingContext context)
{
return(typeof(TChannel) == typeof(IOutputChannel) ||
typeof(TChannel) == typeof(IDuplexChannel));
}
public override IChannelFactory <TChannel> BuildChannelFactory <TChannel>(BindingContext context)
{
return(default(IChannelFactory <TChannel>));
}