695 lines
26 KiB
C#
695 lines
26 KiB
C#
//----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Diagnostics;
|
|
using System.Net;
|
|
using System.Runtime;
|
|
using System.Security;
|
|
using System.Security.Authentication.ExtendedProtection;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.Threading;
|
|
using System.Runtime.Diagnostics;
|
|
|
|
class SharedHttpTransportManager : HttpTransportManager
|
|
{
|
|
int maxPendingAccepts;
|
|
HttpListener listener;
|
|
ManualResetEvent listenStartedEvent;
|
|
Exception listenStartedException;
|
|
AsyncCallback onGetContext;
|
|
AsyncCallback onContextReceived;
|
|
Action onMessageDequeued;
|
|
Action<object> onCompleteGetContextLater;
|
|
bool unsafeConnectionNtlmAuthentication;
|
|
ReaderWriterLockSlim listenerRWLock;
|
|
|
|
internal SharedHttpTransportManager(Uri listenUri, HttpChannelListener channelListener)
|
|
: base(listenUri, channelListener.HostNameComparisonMode, channelListener.Realm)
|
|
{
|
|
this.onGetContext = Fx.ThunkCallback(new AsyncCallback(OnGetContext));
|
|
this.onMessageDequeued = new Action(OnMessageDequeued);
|
|
this.unsafeConnectionNtlmAuthentication = channelListener.UnsafeConnectionNtlmAuthentication;
|
|
this.onContextReceived = new AsyncCallback(this.HandleHttpContextReceived);
|
|
this.listenerRWLock = new ReaderWriterLockSlim();
|
|
|
|
this.maxPendingAccepts = channelListener.MaxPendingAccepts;
|
|
}
|
|
|
|
// We are NOT checking the RequestInitializationTimeout here since the HttpChannelListener should be handle them
|
|
// individually. However, some of the scenarios might be impacted, e.g., if we have one endpoint with high RequestInitializationTimeout
|
|
// and the other is just normal, the first endpoint might be occupying all the receiving loops, then the requests to the normal endpoint
|
|
// will experience timeout issues. The mitigation for this issue is that customers should be able to increase the MaxPendingAccepts number.
|
|
internal override bool IsCompatible(HttpChannelListener channelListener)
|
|
{
|
|
if (channelListener.InheritBaseAddressSettings)
|
|
return true;
|
|
|
|
if (!channelListener.IsScopeIdCompatible(HostNameComparisonMode, this.ListenUri))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (this.maxPendingAccepts != channelListener.MaxPendingAccepts)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return channelListener.UnsafeConnectionNtlmAuthentication == this.unsafeConnectionNtlmAuthentication
|
|
&& base.IsCompatible(channelListener);
|
|
}
|
|
|
|
internal override void OnClose(TimeSpan timeout)
|
|
{
|
|
Cleanup(false, timeout);
|
|
}
|
|
|
|
internal override void OnAbort()
|
|
{
|
|
Cleanup(true, TimeSpan.Zero);
|
|
base.OnAbort();
|
|
}
|
|
|
|
void Cleanup(bool aborting, TimeSpan timeout)
|
|
{
|
|
using (LockHelper.TakeWriterLock(this.listenerRWLock))
|
|
{
|
|
HttpListener listenerSnapshot = this.listener;
|
|
if (listenerSnapshot == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
listenerSnapshot.Stop();
|
|
}
|
|
finally
|
|
{
|
|
try
|
|
{
|
|
listenerSnapshot.Close();
|
|
}
|
|
finally
|
|
{
|
|
if (!aborting)
|
|
{
|
|
base.OnClose(timeout);
|
|
}
|
|
else
|
|
{
|
|
base.OnAbort();
|
|
}
|
|
}
|
|
}
|
|
|
|
this.listener = null;
|
|
}
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Calls into critical method ExecutionContext.SuppressFlow",
|
|
Safe = "Doesn't leak information\\resources; the callback that is invoked is safe")]
|
|
[SecuritySafeCritical]
|
|
IAsyncResult BeginGetContext(bool startListening)
|
|
{
|
|
EventTraceActivity eventTraceActivity = null;
|
|
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
|
|
{
|
|
eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate(true);
|
|
if (TD.HttpGetContextStartIsEnabled())
|
|
{
|
|
TD.HttpGetContextStart(eventTraceActivity);
|
|
}
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
Exception unexpectedException = null;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
if (ExecutionContext.IsFlowSuppressed())
|
|
{
|
|
return this.BeginGetContextCore(eventTraceActivity);
|
|
}
|
|
else
|
|
{
|
|
using (ExecutionContext.SuppressFlow())
|
|
{
|
|
return this.BeginGetContextCore(eventTraceActivity);
|
|
}
|
|
}
|
|
}
|
|
catch (HttpListenerException e)
|
|
{
|
|
if (!this.HandleHttpException(e))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
if (startListening)
|
|
{
|
|
// Since we're under a call to StartListening(), just throw the exception up the stack.
|
|
throw;
|
|
}
|
|
unexpectedException = e;
|
|
}
|
|
|
|
if (unexpectedException != null)
|
|
{
|
|
this.Fault(unexpectedException);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
IAsyncResult BeginGetContextCore(EventTraceActivity eventTraceActivity)
|
|
{
|
|
using (LockHelper.TakeReaderLock(this.listenerRWLock))
|
|
{
|
|
if (this.listener == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return this.listener.BeginGetContext(onGetContext, eventTraceActivity);
|
|
}
|
|
}
|
|
|
|
void OnGetContext(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
|
|
OnGetContextCore(result);
|
|
}
|
|
|
|
void OnCompleteGetContextLater(object state)
|
|
{
|
|
OnGetContextCore((IAsyncResult)state);
|
|
}
|
|
|
|
void OnGetContextCore(IAsyncResult listenerContextResult)
|
|
{
|
|
Fx.Assert(listenerContextResult != null, "listenerContextResult cannot be null.");
|
|
bool enqueued = false;
|
|
|
|
while (!enqueued)
|
|
{
|
|
Exception unexpectedException = null;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
enqueued = this.EnqueueContext(listenerContextResult);
|
|
}
|
|
catch (HttpListenerException e)
|
|
{
|
|
if (!this.HandleHttpException(e))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (Fx.IsFatal(exception))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
unexpectedException = exception;
|
|
}
|
|
|
|
if (unexpectedException != null)
|
|
{
|
|
this.Fault(unexpectedException);
|
|
}
|
|
|
|
// NormalHttpPipeline calls HttpListener.BeginGetContext() by itself (via its dequeuedCallback) in the short-circuit case
|
|
// when there was no error processing the inboud request (see the comments in the NormalHttpPipeline.Close() for details).
|
|
if (!enqueued) // onMessageDequeued will handle this in the enqueued case
|
|
{
|
|
// Continue the loop with the async result if it completed synchronously.
|
|
listenerContextResult = this.BeginGetContext(false);
|
|
if ((listenerContextResult == null) || !listenerContextResult.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool EnqueueContext(IAsyncResult listenerContextResult)
|
|
{
|
|
EventTraceActivity eventTraceActivity = null;
|
|
HttpListenerContext listenerContext;
|
|
bool enqueued = false;
|
|
|
|
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
|
|
{
|
|
eventTraceActivity = (EventTraceActivity)listenerContextResult.AsyncState;
|
|
if (eventTraceActivity == null)
|
|
{
|
|
eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate(true);
|
|
}
|
|
}
|
|
|
|
using (LockHelper.TakeReaderLock(this.listenerRWLock))
|
|
{
|
|
if (this.listener == null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
listenerContext = this.listener.EndGetContext(listenerContextResult);
|
|
}
|
|
|
|
// Grab the activity from the context and set that as the surrounding activity.
|
|
// If a message appears, we will transfer to the message's activity next
|
|
using (DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.BoundOperation(this.Activity) : null)
|
|
{
|
|
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivityWithTransferInOnly(listenerContext.Request.RequestTraceIdentifier) : null;
|
|
try
|
|
{
|
|
if (activity != null)
|
|
{
|
|
StartReceiveBytesActivity(activity, listenerContext.Request.Url);
|
|
}
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceHttpConnectionInformation(listenerContext.Request.LocalEndPoint.ToString(),
|
|
listenerContext.Request.RemoteEndPoint.ToString(), this);
|
|
}
|
|
|
|
base.TraceMessageReceived(eventTraceActivity, this.ListenUri);
|
|
|
|
HttpChannelListener channelListener;
|
|
if (base.TryLookupUri(listenerContext.Request.Url,
|
|
listenerContext.Request.HttpMethod,
|
|
this.HostNameComparisonMode,
|
|
listenerContext.Request.IsWebSocketRequest,
|
|
out channelListener))
|
|
{
|
|
HttpRequestContext context = HttpRequestContext.CreateContext(channelListener, listenerContext, eventTraceActivity);
|
|
|
|
IAsyncResult httpContextReceivedResult = channelListener.BeginHttpContextReceived(context,
|
|
onMessageDequeued,
|
|
onContextReceived,
|
|
DiagnosticUtility.ShouldUseActivity ? (object)new ActivityHolder(activity, context) : (object)context);
|
|
if (httpContextReceivedResult.CompletedSynchronously)
|
|
{
|
|
enqueued = EndHttpContextReceived(httpContextReceivedResult);
|
|
}
|
|
else
|
|
{
|
|
// The callback has been enqueued.
|
|
enqueued = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HandleMessageReceiveFailed(listenerContext);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity && activity != null)
|
|
{
|
|
if (!enqueued)
|
|
{
|
|
// Error during enqueuing
|
|
activity.Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return enqueued;
|
|
}
|
|
|
|
void HandleHttpContextReceived(IAsyncResult httpContextReceivedResult)
|
|
{
|
|
if (httpContextReceivedResult.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool enqueued = false;
|
|
Exception unexpectedException = null;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
enqueued = EndHttpContextReceived(httpContextReceivedResult);
|
|
}
|
|
catch (HttpListenerException e)
|
|
{
|
|
if (!this.HandleHttpException(e))
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
if (Fx.IsFatal(exception))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
unexpectedException = exception;
|
|
}
|
|
|
|
if (unexpectedException != null)
|
|
{
|
|
this.Fault(unexpectedException);
|
|
}
|
|
|
|
IAsyncResult listenerContextResult = null;
|
|
if (!enqueued) // onMessageDequeued will handle this in the enqueued case
|
|
{
|
|
listenerContextResult = this.BeginGetContext(false);
|
|
if ((listenerContextResult == null) || !listenerContextResult.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Handle the context and continue the receive loop.
|
|
this.OnGetContextCore(listenerContextResult);
|
|
}
|
|
}
|
|
|
|
static bool EndHttpContextReceived(IAsyncResult httpContextReceivedResult)
|
|
{
|
|
using (DiagnosticUtility.ShouldUseActivity ? (ActivityHolder)httpContextReceivedResult.AsyncState : null)
|
|
{
|
|
HttpChannelListener channelListener =
|
|
(DiagnosticUtility.ShouldUseActivity ?
|
|
((ActivityHolder)httpContextReceivedResult.AsyncState).context :
|
|
(HttpRequestContext)httpContextReceivedResult.AsyncState).Listener;
|
|
|
|
return channelListener.EndHttpContextReceived(httpContextReceivedResult);
|
|
}
|
|
}
|
|
|
|
bool HandleHttpException(HttpListenerException e)
|
|
{
|
|
switch (e.ErrorCode)
|
|
{
|
|
case UnsafeNativeMethods.ERROR_NOT_ENOUGH_MEMORY:
|
|
case UnsafeNativeMethods.ERROR_OUTOFMEMORY:
|
|
case UnsafeNativeMethods.ERROR_NO_SYSTEM_RESOURCES:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InsufficientMemoryException(SR.GetString(SR.InsufficentMemory), e));
|
|
default:
|
|
return ExceptionHandler.HandleTransportExceptionHelper(e);
|
|
}
|
|
}
|
|
|
|
static void HandleMessageReceiveFailed(HttpListenerContext listenerContext)
|
|
{
|
|
TraceMessageReceiveFailed();
|
|
|
|
// no match -- 405 or 404
|
|
if (string.Compare(listenerContext.Request.HttpMethod, "POST", StringComparison.OrdinalIgnoreCase) != 0)
|
|
{
|
|
listenerContext.Response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
|
|
listenerContext.Response.Headers.Add(HttpResponseHeader.Allow, "POST");
|
|
}
|
|
else
|
|
{
|
|
listenerContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
|
|
}
|
|
|
|
listenerContext.Response.ContentLength64 = 0;
|
|
listenerContext.Response.Close();
|
|
}
|
|
|
|
static void TraceMessageReceiveFailed()
|
|
{
|
|
if (TD.HttpMessageReceiveStartIsEnabled())
|
|
{
|
|
TD.HttpMessageReceiveFailed();
|
|
}
|
|
|
|
if (DiagnosticUtility.ShouldTraceWarning)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.HttpChannelMessageReceiveFailed,
|
|
SR.GetString(SR.TraceCodeHttpChannelMessageReceiveFailed), (object)null);
|
|
}
|
|
}
|
|
|
|
void StartListening()
|
|
{
|
|
for (int i = 0; i < maxPendingAccepts; i++)
|
|
{
|
|
IAsyncResult result = this.BeginGetContext(true);
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
if (onCompleteGetContextLater == null)
|
|
{
|
|
onCompleteGetContextLater = new Action<object>(OnCompleteGetContextLater);
|
|
}
|
|
ActionItem.Schedule(onCompleteGetContextLater, result);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnListening(object state)
|
|
{
|
|
try
|
|
{
|
|
this.StartListening();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
this.listenStartedException = e;
|
|
}
|
|
finally
|
|
{
|
|
this.listenStartedEvent.Set();
|
|
}
|
|
}
|
|
|
|
void OnMessageDequeued()
|
|
{
|
|
ThreadTrace.Trace("message dequeued");
|
|
IAsyncResult result = this.BeginGetContext(false);
|
|
if (result != null && result.CompletedSynchronously)
|
|
{
|
|
if (onCompleteGetContextLater == null)
|
|
{
|
|
onCompleteGetContextLater = new Action<object>(OnCompleteGetContextLater);
|
|
}
|
|
ActionItem.Schedule(onCompleteGetContextLater, result);
|
|
}
|
|
}
|
|
|
|
internal override void OnOpen()
|
|
{
|
|
listener = new HttpListener();
|
|
|
|
string host;
|
|
|
|
switch (HostNameComparisonMode)
|
|
{
|
|
case HostNameComparisonMode.Exact:
|
|
// Uri.DnsSafeHost strips the [], but preserves the scopeid for IPV6 addresses.
|
|
if (ListenUri.HostNameType == UriHostNameType.IPv6)
|
|
{
|
|
host = string.Concat("[", ListenUri.DnsSafeHost, "]");
|
|
}
|
|
else
|
|
{
|
|
host = ListenUri.NormalizedHost();
|
|
}
|
|
break;
|
|
|
|
case HostNameComparisonMode.StrongWildcard:
|
|
host = "+";
|
|
break;
|
|
|
|
case HostNameComparisonMode.WeakWildcard:
|
|
host = "*";
|
|
break;
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnrecognizedHostNameComparisonMode, HostNameComparisonMode.ToString())));
|
|
}
|
|
|
|
string path = ListenUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
|
|
if (!path.StartsWith("/", StringComparison.Ordinal))
|
|
path = "/" + path;
|
|
|
|
if (!path.EndsWith("/", StringComparison.Ordinal))
|
|
path = path + "/";
|
|
|
|
string httpListenUrl = string.Concat(Scheme, "://", host, ":", ListenUri.Port, path);
|
|
|
|
listener.UnsafeConnectionNtlmAuthentication = this.unsafeConnectionNtlmAuthentication;
|
|
listener.AuthenticationSchemeSelectorDelegate =
|
|
new AuthenticationSchemeSelector(SelectAuthenticationScheme);
|
|
|
|
if (ExtendedProtectionPolicy.OSSupportsExtendedProtection)
|
|
{
|
|
//This API will throw if on an unsupported platform.
|
|
listener.ExtendedProtectionSelectorDelegate =
|
|
new HttpListener.ExtendedProtectionSelector(SelectExtendedProtectionPolicy);
|
|
}
|
|
|
|
if (this.Realm != null)
|
|
{
|
|
listener.Realm = this.Realm;
|
|
}
|
|
|
|
bool success = false;
|
|
try
|
|
{
|
|
listener.Prefixes.Add(httpListenUrl);
|
|
listener.Start();
|
|
|
|
bool startedListening = false;
|
|
try
|
|
{
|
|
if (Thread.CurrentThread.IsThreadPoolThread)
|
|
{
|
|
StartListening();
|
|
}
|
|
else
|
|
{
|
|
// If we're not on a threadpool thread, then we need to post a callback to start our accepting loop
|
|
// Otherwise if the calling thread aborts then the async I/O will get inadvertantly cancelled
|
|
listenStartedEvent = new ManualResetEvent(false);
|
|
ActionItem.Schedule(OnListening, null);
|
|
listenStartedEvent.WaitOne();
|
|
listenStartedEvent.Close();
|
|
listenStartedEvent = null;
|
|
if (listenStartedException != null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(listenStartedException);
|
|
}
|
|
}
|
|
startedListening = true;
|
|
}
|
|
finally
|
|
{
|
|
if (!startedListening)
|
|
{
|
|
listener.Stop();
|
|
}
|
|
}
|
|
|
|
success = true;
|
|
}
|
|
catch (HttpListenerException listenerException)
|
|
{
|
|
switch (listenerException.NativeErrorCode)
|
|
{
|
|
case UnsafeNativeMethods.ERROR_ALREADY_EXISTS:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(SR.GetString(SR.HttpRegistrationAlreadyExists, httpListenUrl), listenerException));
|
|
|
|
case UnsafeNativeMethods.ERROR_SHARING_VIOLATION:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAlreadyInUseException(SR.GetString(SR.HttpRegistrationPortInUse, httpListenUrl, ListenUri.Port), listenerException));
|
|
|
|
case UnsafeNativeMethods.ERROR_ACCESS_DENIED:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new AddressAccessDeniedException(SR.GetString(SR.HttpRegistrationAccessDenied, httpListenUrl), listenerException));
|
|
|
|
case UnsafeNativeMethods.ERROR_ALLOTTED_SPACE_EXCEEDED:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.HttpRegistrationLimitExceeded, httpListenUrl), listenerException));
|
|
|
|
case UnsafeNativeMethods.ERROR_INVALID_PARAMETER:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.HttpInvalidListenURI, ListenUri.OriginalString), listenerException));
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
HttpChannelUtilities.CreateCommunicationException(listenerException));
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (!success)
|
|
{
|
|
listener.Abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
AuthenticationSchemes SelectAuthenticationScheme(HttpListenerRequest request)
|
|
{
|
|
try
|
|
{
|
|
AuthenticationSchemes result;
|
|
HttpChannelListener channelListener;
|
|
if (base.TryLookupUri(request.Url, request.HttpMethod,
|
|
this.HostNameComparisonMode, request.IsWebSocketRequest, out channelListener))
|
|
{
|
|
result = channelListener.AuthenticationScheme;
|
|
}
|
|
else
|
|
{
|
|
// if we don't match a listener factory, we want to "fall through" the
|
|
// auth delegate code and run through our normal OnGetContext codepath.
|
|
// System.Net treats "None" as Access Denied, which is not our intent here.
|
|
// In most cases this will just fall through to the code that returns a "404 Not Found"
|
|
result = AuthenticationSchemes.Anonymous;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
ExtendedProtectionPolicy SelectExtendedProtectionPolicy(HttpListenerRequest request)
|
|
{
|
|
ExtendedProtectionPolicy result = null;
|
|
|
|
try
|
|
{
|
|
HttpChannelListener channelListener;
|
|
if (base.TryLookupUri(request.Url, request.HttpMethod,
|
|
this.HostNameComparisonMode, request.IsWebSocketRequest, out channelListener))
|
|
{
|
|
result = channelListener.ExtendedProtectionPolicy;
|
|
}
|
|
else
|
|
{
|
|
//if the listener isn't found, then the auth scheme will be anonymous
|
|
//(see SelectAuthenticationScheme function) and will fall through to the
|
|
//404 Not Found code path, so it doesn't really matter what we return from here...
|
|
result = ChannelBindingUtility.DisabledPolicy;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
}
|