Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / Net / System / Net / HttpListener.cs / 1 / HttpListener.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
//disabled until BindHandle has an overload that accepts Criticalhandles
#pragma warning disable 618
namespace System.Net {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Security;
using System.Security.Principal;
using System.Security.Cryptography.X509Certificates;
using Microsoft.Win32;
public class HttpListenerBasicIdentity : GenericIdentity
{
private string m_Password;
public HttpListenerBasicIdentity(string username, string password) :
base(username, BasicClient.AuthType)
{
m_Password = password;
}
public virtual string Password
{
get
{
return m_Password;
}
}
}
internal abstract unsafe class RequestContextBase : IDisposable
{
private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* m_MemoryBlob;
private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* m_OriginalBlobAddress;
private byte[] m_BackingBuffer;
// Must call this from derived class' constructors.
protected void BaseConstruction(UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* requestBlob)
{
if (requestBlob == null)
{
GC.SuppressFinalize(this);
}
else
{
m_MemoryBlob = requestBlob;
}
}
// ReleasePins() should be called exactly once. It must be called before Dispose() is called, which means it must be called
// before an object (HttpListenerReqeust) which closes the RequestContext on demand is returned to the application.
internal void ReleasePins()
{
GlobalLog.Assert(m_MemoryBlob != null || m_BackingBuffer == null, "RequestContextBase::ReleasePins()|ReleasePins() called twice.");
m_OriginalBlobAddress = m_MemoryBlob;
UnsetBlob();
OnReleasePins();
}
protected abstract void OnReleasePins();
public void Close()
{
Dispose();
}
public void Dispose()
{
GlobalLog.Assert(m_MemoryBlob == null, "RequestContextBase::Dispose()|Dispose() called before ReleasePins().");
Dispose(true);
}
protected virtual void Dispose(bool disposing) { }
~RequestContextBase()
{
Dispose(false);
}
internal UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* RequestBlob
{
get
{
GlobalLog.Assert(m_MemoryBlob != null || m_BackingBuffer == null, "RequestContextBase::Dispose()|RequestBlob requested after ReleasePins().");
return m_MemoryBlob;
}
}
internal byte[] RequestBuffer
{
get
{
return m_BackingBuffer;
}
}
internal uint Size
{
get
{
return (uint) m_BackingBuffer.Length;
}
}
internal IntPtr OriginalBlobAddress
{
get
{
UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* blob = m_MemoryBlob;
return (IntPtr) (blob == null ? m_OriginalBlobAddress : blob);
}
}
protected void SetBlob(UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* requestBlob)
{
GlobalLog.Assert(m_MemoryBlob != null || m_BackingBuffer == null, "RequestContextBase::Dispose()|SetBlob() called after ReleasePins().");
if (requestBlob == null)
{
UnsetBlob();
return;
}
if (m_MemoryBlob == null)
{
GC.ReRegisterForFinalize(this);
}
m_MemoryBlob = requestBlob;
}
protected void UnsetBlob()
{
if (m_MemoryBlob != null)
{
GC.SuppressFinalize(this);
}
m_MemoryBlob = null;
}
protected void SetBuffer(int size)
{
m_BackingBuffer = size == 0 ? null : new byte[size];
}
}
internal unsafe class AsyncRequestContext : RequestContextBase
{
private NativeOverlapped* m_NativeOverlapped;
private ListenerAsyncResult m_Result;
internal AsyncRequestContext(ListenerAsyncResult result)
{
m_Result = result;
BaseConstruction(Allocate(0));
}
private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* Allocate(uint size)
{
uint newSize = size != 0 ? size : RequestBuffer == null ? 4096 : Size;
if (m_NativeOverlapped != null && newSize != RequestBuffer.Length)
{
NativeOverlapped* nativeOverlapped = m_NativeOverlapped;
m_NativeOverlapped = null;
Overlapped.Free(nativeOverlapped);
}
if (m_NativeOverlapped == null)
{
SetBuffer(checked((int) newSize));
Overlapped overlapped = new Overlapped();
overlapped.AsyncResult = m_Result;
m_NativeOverlapped = overlapped.Pack(ListenerAsyncResult.IOCallback, RequestBuffer);
return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*) Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);
}
return RequestBlob;
}
internal void Reset(ulong requestId, uint size)
{
SetBlob(Allocate(size));
RequestBlob->RequestId = requestId;
}
protected override void OnReleasePins()
{
if (m_NativeOverlapped != null)
{
NativeOverlapped* nativeOverlapped = m_NativeOverlapped;
m_NativeOverlapped = null;
Overlapped.Free(nativeOverlapped);
}
}
protected override void Dispose(bool disposing)
{
if (m_NativeOverlapped != null)
{
GlobalLog.Assert(!disposing, "AsyncRequestContext::Dispose()|Must call ReleasePins() before calling Dispose().");
if (!NclUtilities.HasShutdownStarted || disposing)
{
Overlapped.Free(m_NativeOverlapped);
}
}
base.Dispose(disposing);
}
internal NativeOverlapped* NativeOverlapped
{
get
{
return m_NativeOverlapped;
}
}
}
internal unsafe class SyncRequestContext : RequestContextBase
{
private GCHandle m_PinnedHandle;
internal SyncRequestContext(int size)
{
BaseConstruction(Allocate(size));
}
private UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST* Allocate(int size)
{
if (m_PinnedHandle.IsAllocated)
{
if (RequestBuffer.Length == size)
{
return RequestBlob;
}
m_PinnedHandle.Free();
}
SetBuffer(size);
if (RequestBuffer == null)
{
return null;
}
m_PinnedHandle = GCHandle.Alloc(RequestBuffer, GCHandleType.Pinned);
return (UnsafeNclNativeMethods.HttpApi.HTTP_REQUEST*) Marshal.UnsafeAddrOfPinnedArrayElement(RequestBuffer, 0);
}
internal void Reset(int size)
{
SetBlob(Allocate(size));
}
protected override void OnReleasePins()
{
if (m_PinnedHandle.IsAllocated)
{
m_PinnedHandle.Free();
}
}
protected override void Dispose(bool disposing)
{
if (m_PinnedHandle.IsAllocated)
{
GlobalLog.Assert(!disposing, "AsyncRequestContext::Dispose()|Must call ReleasePins() before calling Dispose().");
if (!NclUtilities.HasShutdownStarted || disposing)
{
m_PinnedHandle.Free();
}
}
base.Dispose(disposing);
}
}
public sealed unsafe class HttpListener : IDisposable
{
private static byte[] s_WwwAuthenticateBytes = new byte[]
{
(byte) 'W', (byte) 'W', (byte) 'W', (byte) '-', (byte) 'A', (byte) 'u', (byte) 't', (byte) 'h',
(byte) 'e', (byte) 'n', (byte) 't', (byte) 'i', (byte) 'c', (byte) 'a', (byte) 't', (byte) 'e'
};
private class AuthenticationSelectorInfo
{
private AuthenticationSchemeSelector m_SelectorDelegate;
private bool m_CanUseAdvancedAuth;
internal AuthenticationSelectorInfo(AuthenticationSchemeSelector selectorDelegate, bool canUseAdvancedAuth)
{
m_SelectorDelegate = selectorDelegate;
m_CanUseAdvancedAuth = canUseAdvancedAuth;
}
internal AuthenticationSchemeSelector Delegate
{
get
{
return m_SelectorDelegate;
}
}
internal bool AdvancedAuth
{
get
{
return m_CanUseAdvancedAuth;
}
}
}
private AuthenticationSelectorInfo m_AuthenticationDelegate;
private AuthenticationSchemes m_AuthenticationScheme = AuthenticationSchemes.Anonymous;
private SecurityException m_SecurityException;
private string m_Realm;
private SafeCloseHandle m_RequestQueueHandle;
private bool m_RequestHandleBound;
private State m_State;
private HttpListenerPrefixCollection m_Prefixes;
private bool m_IgnoreWriteExceptions;
private bool m_UnsafeConnectionNtlmAuthentication;
private Hashtable m_DisconnectResults; // ulong -> DisconnectAsyncResult
private object m_InternalLock;
internal Hashtable m_UriPrefixes = new Hashtable();
public HttpListener() {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "HttpListener", "");
if (!UnsafeNclNativeMethods.HttpApi.Supported) {
throw new PlatformNotSupportedException();
}
m_State = State.Stopped;
m_InternalLock = new object();
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "HttpListener", "");
}
internal SafeCloseHandle RequestQueueHandle {
get {
return m_RequestQueueHandle;
}
}
public AuthenticationSchemeSelector AuthenticationSchemeSelectorDelegate {
get {
AuthenticationSelectorInfo selector = m_AuthenticationDelegate;
return selector == null ? null : selector.Delegate;
}
set {
CheckDisposed();
try
{
new SecurityPermission(SecurityPermissionFlag.ControlPrincipal).Demand();
m_AuthenticationDelegate = new AuthenticationSelectorInfo(value, true);
}
catch (SecurityException exception)
{
m_SecurityException = exception;
m_AuthenticationDelegate = new AuthenticationSelectorInfo(value, false);
}
}
}
public AuthenticationSchemes AuthenticationSchemes {
get {
return m_AuthenticationScheme;
}
set {
CheckDisposed();
// Enabling certain schemes requires special permissions.
if ((value & (AuthenticationSchemes.Digest | AuthenticationSchemes.Negotiate | AuthenticationSchemes.Ntlm)) != 0)
{
new SecurityPermission(SecurityPermissionFlag.ControlPrincipal).Demand();
}
m_AuthenticationScheme = value;
}
}
public string Realm {
get {
return m_Realm;
}
set {
CheckDisposed();
m_Realm = value;
}
}
public static bool IsSupported {
get {
return UnsafeNclNativeMethods.HttpApi.Supported;
}
}
public bool IsListening {
get {
return m_State==State.Started;
}
}
public bool IgnoreWriteExceptions {
get {
return m_IgnoreWriteExceptions;
}
set {
CheckDisposed();
m_IgnoreWriteExceptions = value;
}
}
public bool UnsafeConnectionNtlmAuthentication {
get {
return m_UnsafeConnectionNtlmAuthentication;
}
set {
CheckDisposed();
if (m_UnsafeConnectionNtlmAuthentication==value) {
return;
}
lock (DisconnectResults.SyncRoot)
{
if (m_UnsafeConnectionNtlmAuthentication == value)
{
return;
}
m_UnsafeConnectionNtlmAuthentication = value;
if (!value)
{
foreach (DisconnectAsyncResult result in DisconnectResults.Values)
{
result.AuthenticatedConnection = null;
}
}
}
}
}
private Hashtable DisconnectResults
{
get
{
if (m_DisconnectResults == null)
{
lock (m_InternalLock)
{
if (m_DisconnectResults == null)
{
m_DisconnectResults = Hashtable.Synchronized(new Hashtable());
}
}
}
return m_DisconnectResults;
}
}
internal void AddPrefix(string uriPrefix)
{
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "AddPrefix", "uriPrefix:" + uriPrefix);
string registeredPrefix = null;
try {
if (uriPrefix==null) {
throw new ArgumentNullException("uriPrefix");
}
(new WebPermission(NetworkAccess.Accept, uriPrefix)).Demand();
CheckDisposed();
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::AddPrefix() uriPrefix:" + uriPrefix);
int i;
if (string.Compare(uriPrefix, 0, "http://", 0, 7, StringComparison.OrdinalIgnoreCase)==0) {
i = 7;
}
else if (string.Compare(uriPrefix, 0, "https://", 0, 8, StringComparison.OrdinalIgnoreCase)==0) {
i = 8;
}
else {
throw new ArgumentException(SR.GetString(SR.net_listener_scheme), "uriPrefix");
}
bool inSquareBrakets = false;
int j = i;
while (j0) {
if (m_State==State.Started) {
foreach (string registeredPrefix in m_UriPrefixes.Values) {
// ignore possible failures
InternalRemovePrefix(registeredPrefix);
}
}
if(clear)
m_UriPrefixes.Clear();
}
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "RemoveAll", "");
}
}
[SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.UnmanagedCode)]
internal void EnsureBoundHandle()
{
if (!m_RequestHandleBound)
{
lock (m_InternalLock)
{
if (!m_RequestHandleBound)
{
ThreadPool.BindHandle(m_RequestQueueHandle.DangerousGetHandle());
m_RequestHandleBound = true;
}
}
}
}
public void Start() {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "Start", "");
try {
CheckDisposed();
if (m_State==State.Started) {
return;
}
m_RequestQueueHandle = SafeCloseHandle.CreateRequestQueueHandle();
AddAll();
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::.ctor() SafeCloseHandle.CreateRequestQueueHandle() returned m_RequestQueueHandle:" + m_RequestQueueHandle);
m_State = State.Started;
} catch (Exception exception) {
if(Logging.On)Logging.Exception(Logging.HttpListener, this, "Start", exception);
throw;
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "Start", "");
}
}
public void Stop() {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "Stop", "");
try {
CheckDisposed();
if (m_State==State.Stopped) {
return;
}
RemoveAll(false);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::Stop() calling SafeCloseHandle.Close()");
m_RequestQueueHandle.Close();
m_RequestHandleBound = false;
m_State = State.Stopped;
ClearDigestCache();
} catch (Exception exception) {
if(Logging.On)Logging.Exception(Logging.HttpListener, this, "Stop", exception);
throw;
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "Stop", "");
}
}
public void Abort() {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "Abort", "");
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::Abort()");
try {
if (m_RequestQueueHandle!=null)
{
m_RequestQueueHandle.Abort();
}
m_RequestHandleBound = false;
m_State = State.Closed;
ClearDigestCache();
} catch (Exception exception) {
if(Logging.On)Logging.Exception(Logging.HttpListener, this, "Abort", exception);
throw;
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "Abort", "");
}
}
public void Close() {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "Close", "");
try {
GlobalLog.Print("HttpListenerRequest::Close()");
((IDisposable)this).Dispose();
} catch (Exception exception) {
if(Logging.On)Logging.Exception(Logging.HttpListener, this, "Close", exception);
throw;
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "Close", "");
}
}
// old API, now private, and helper methods
private void Dispose(bool disposing) {
if(Logging.On)Logging.Enter(Logging.HttpListener, this, "Dispose", "");
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::Dispose()");
try {
if (m_State == State.Closed){
return;
}
Stop();
m_RequestHandleBound = false;
m_State = State.Closed;
} catch (Exception exception) {
if(Logging.On)Logging.Exception(Logging.HttpListener, this, "Dispose", exception);
throw;
} finally {
if(Logging.On)Logging.Exit(Logging.HttpListener, this, "Dispose", "");
}
}
/// " : authorizationHeader)));
// If anonymous is allowed, just return the context. Otherwise go for the 401.
if ((authenticationScheme & AuthenticationSchemes.Anonymous) != AuthenticationSchemes.None)
{
if (!stoleBlob)
{
stoleBlob = true;
httpContext.Request.ReleasePins();
}
return httpContext;
}
httpError = HttpStatusCode.Unauthorized;
httpContext.Request.DetachBlob(memoryBlob);
httpContext.Close();
httpContext = null;
}
else
{
// Perform Authentication
byte[] bytes = null;
byte[] decodedOutgoingBlob = null;
string outBlob = null;
// Find the beginning of the blob. Trust that HTTP.SYS parsed out just our header ok.
for (index++; index < authorizationHeader.Length; index++)
{
if (authorizationHeader[index] != ' ' && authorizationHeader[index] != '\t' &&
authorizationHeader[index] != '\r' && authorizationHeader[index] != '\n')
{
break;
}
}
string inBlob = index < authorizationHeader.Length ? authorizationHeader.Substring(index) : "";
IPrincipal principal = null;
SecurityStatus statusCodeNew;
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() Performing Authentication headerScheme:" + ValidationHelper.ToString(headerScheme));
switch (headerScheme)
{
case AuthenticationSchemes.Digest:
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() package:WDigest headerScheme:" + headerScheme);
// WDigest had some weird behavior. This is what I have discovered:
// Local accounts don't work, only domain accounts. The domain (i.e. REDMOND) is implied. Not sure how it is chosen.
// If the domain is specified and the credentials are correct, it works. If they're not (domain, username or password):
// AcceptSecurityContext (GetOutgoingDigestBlob) returns success but with a bogus 4k challenge, and
// QuerySecurityContextToken (GetContextToken) fails with NoImpersonation.
// If the domain isn't specified, AcceptSecurityContext returns NoAuthenticatingAuthority for a bad username,
// and LogonDenied for a bad password.
// Also interesting is that WDigest requires us to keep a reference to the previous context, but fails if we
// actually pass it in! (It't ok to pass it in for the first request, but not if nc > 1.) For Whidbey,
// we create a new context and associate it with the connection, just like NTLM, but instead of using it for
// the next request on the connection, we always create a new context and swap the old one out. As long
// as we keep the old one around until after we authenticate with the new one, it works. For this reason,
// we also keep these contexts around past the lifetime of the connection, so that KeepAlive=false works.
context = new NTAuthentication(true, NegotiationInfoClass.WDigest, null, ContextFlags.Connection);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() verb:" + verb + " context.IsValidContext:" + context.IsValidContext.ToString());
outBlob = context.GetOutgoingDigestBlob(inBlob, verb, null, Realm, false, false, out statusCodeNew);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() GetOutgoingDigestBlob() returned IsCompleted:" + context.IsCompleted + " statusCodeNew:" + statusCodeNew + " outBlob:[" + outBlob + "]");
// WDigest bug: sometimes when AcceptSecurityContext returns success, it provides a bogus, empty 4k buffer.
// Ignore it. (Should find out what's going on here from WDigest people.)
if (statusCodeNew == SecurityStatus.OK)
{
outBlob = null;
}
if (context.IsValidContext)
{
SafeCloseHandle userContext = null;
try
{
userContext = context.GetContextToken(out statusCodeNew);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() GetContextToken() returned:" + statusCodeNew.ToString());
if (statusCodeNew != SecurityStatus.OK)
{
httpError = HttpStatusFromSecurityStatus(statusCodeNew);
}
else if (userContext == null)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() error: GetContextToken() returned:null statusCodeNew:" + statusCodeNew.ToString());
httpError = HttpStatusCode.Unauthorized;
}
else
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() creating new WindowsIdentity() from userContext:" + userContext.DangerousGetHandle().ToString("x8"));
principal = new WindowsPrincipal(CreateWindowsIdentity(userContext.DangerousGetHandle(), DigestClient.AuthType, WindowsAccountType.Normal, true));
}
}
finally {
if (userContext!=null) {
userContext.Close();
}
}
newContext = context;
if (outBlob != null)
{
challenge = DigestClient.AuthType + " " + outBlob;
}
}
else
{
httpError = HttpStatusFromSecurityStatus(statusCodeNew);
}
break;
case AuthenticationSchemes.Negotiate:
case AuthenticationSchemes.Ntlm:
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() headerScheme:" + headerScheme);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() returned context#" + ValidationHelper.HashString(oldContext) + " for connectionId:" + connectionId);
string package = headerScheme == AuthenticationSchemes.Ntlm ? NtlmClient.AuthType : NegotiateClient.AuthType;
if (oldContext != null && oldContext.Package == package)
{
context = oldContext;
}
else
{
context = new NTAuthentication(true, package, null, ContextFlags.Connection);
}
try
{
bytes = Convert.FromBase64String(inBlob);
}
catch (FormatException)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() FromBase64String threw a FormatException.");
httpError = HttpStatusCode.BadRequest;
error = true;
}
if (!error)
{
decodedOutgoingBlob = context.GetOutgoingBlob(bytes, false, out statusCodeNew);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() GetOutgoingBlob() returned IsCompleted:" + context.IsCompleted + " statusCodeNew:" + statusCodeNew);
error = !context.IsValidContext;
if (error)
{
// Bug #474228: SSPI Workaround
// If a client sends up a blob on the initial request, Negotiate returns SEC_E_INVALID_HANDLE
// when it should return SEC_E_INVALID_TOKEN.
if (statusCodeNew == SecurityStatus.InvalidHandle && oldContext == null && bytes != null && bytes.Length > 0)
{
statusCodeNew = SecurityStatus.InvalidToken;
}
httpError = HttpStatusFromSecurityStatus(statusCodeNew);
}
}
if (decodedOutgoingBlob!=null) {
outBlob = Convert.ToBase64String(decodedOutgoingBlob);
}
if (!error)
{
if (context.IsCompleted) {
SafeCloseHandle userContext = null;
try
{
userContext = context.GetContextToken(out statusCodeNew);
if (statusCodeNew != SecurityStatus.OK)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() GetContextToken() failed with statusCodeNew:" + statusCodeNew.ToString());
httpError = HttpStatusFromSecurityStatus(statusCodeNew);
}
else
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() creating new WindowsIdentity() from userContext:" + userContext.DangerousGetHandle().ToString("x8"));
WindowsPrincipal windowsPrincipal = new WindowsPrincipal(CreateWindowsIdentity(userContext.DangerousGetHandle(), context.ProtocolName, WindowsAccountType.Normal, true));
principal = windowsPrincipal;
// if appropriate, cache this credential on this connection
if (UnsafeConnectionNtlmAuthentication && context.ProtocolName == NegotiationInfoClass.NTLM)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() inserting principal#" + ValidationHelper.HashString(principal) + " for connectionId:" + connectionId);
// We may need to call WaitForDisconnect.
if (disconnectResult == null)
{
RegisterForDisconnectNotification(connectionId, ref disconnectResult);
}
if (disconnectResult != null)
{
lock (DisconnectResults.SyncRoot)
{
if (UnsafeConnectionNtlmAuthentication)
{
disconnectResult.AuthenticatedConnection = windowsPrincipal;
}
}
}
else
{
// Registration failed - UnsafeConnectionNtlmAuthentication ignored.
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() RegisterForDisconnectNotification() failed.");
}
}
}
}
finally {
if (userContext!=null) {
userContext.Close();
}
}
}
else
{
// auth incomplete
newContext = context;
challenge = (headerScheme==AuthenticationSchemes.Ntlm ? NtlmClient.AuthType : NegotiateClient.AuthType);
if (!String.IsNullOrEmpty(outBlob))
{
challenge += " " + outBlob;
}
}
}
break;
case AuthenticationSchemes.Basic:
try
{
bytes = Convert.FromBase64String(inBlob);
inBlob = WebHeaderCollection.HeaderEncoding.GetString(bytes, 0, bytes.Length);
index = inBlob.IndexOf(':');
if (index!=-1) {
string userName = inBlob.Substring(0, index);
string password = inBlob.Substring(index+1);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() basic identity found, userName:" + userName);
principal = new GenericPrincipal(new HttpListenerBasicIdentity(userName, password), null);
}
else
{
httpError = HttpStatusCode.BadRequest;
}
}
catch (FormatException)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() FromBase64String threw a FormatException.");
}
break;
}
if (principal != null)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() got principal:" + ValidationHelper.ToString(principal) + " principal.Identity.Name:" + ValidationHelper.ToString(principal.Identity.Name) + " creating request");
httpContext.SetIdentity(principal, outBlob);
}
else
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() handshake has failed");
if(Logging.On)Logging.PrintWarning(Logging.HttpListener, this, "HandleAuthentication", SR.GetString(SR.net_log_listener_create_valid_identity_failed));
httpContext.Request.DetachBlob(memoryBlob);
httpContext.Close();
httpContext = null;
}
}
// if we're not giving a request to the application, we need to send an error
ArrayList challenges = null;
if (httpContext == null)
{
// If we already have a challenge, just use it. Otherwise put a challenge for each acceptable scheme.
if (challenge != null)
{
AddChallenge(ref challenges, challenge);
}
else
{
// We're starting over. Any context SSPI might have wanted us to keep is useless.
if (newContext != null)
{
if (newContext == context)
{
context = null;
}
if (newContext != oldContext)
{
NTAuthentication toClose = newContext;
newContext = null;
toClose.CloseContext();
}
else
{
newContext = null;
}
}
// If we're sending something besides 401, do it here.
if (httpError != HttpStatusCode.Unauthorized)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() failed context#" + ValidationHelper.HashString(context) + " for connectionId:" + connectionId + " because of error:" + httpError.ToString());
SendError(requestId, httpError, null);
return null;
}
challenges = BuildChallenge(authenticationScheme, connectionId, out newContext);
}
}
// Check if we need to call WaitForDisconnect, because if we do and it fails, we want to send a 500 instead.
if (disconnectResult == null && newContext != null)
{
RegisterForDisconnectNotification(connectionId, ref disconnectResult);
// Failed - send 500.
if (disconnectResult == null)
{
if (newContext != null)
{
if (newContext == context)
{
context = null;
}
if (newContext != oldContext)
{
NTAuthentication toClose = newContext;
newContext = null;
toClose.CloseContext();
}
else
{
newContext = null;
}
}
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() failed context#" + ValidationHelper.HashString(context) + " for connectionId:" + connectionId + " because of failed HttpWaitForDisconnect");
SendError(requestId, HttpStatusCode.InternalServerError, null);
httpContext.Request.DetachBlob(memoryBlob);
httpContext.Close();
return null;
}
}
// Update Session if necessary.
if (oldContext != newContext)
{
if (oldContext == context)
{
// Prevent the finally from closing this twice.
context = null;
}
NTAuthentication toClose = oldContext;
oldContext = newContext;
disconnectResult.Session = newContext;
if (toClose != null)
{
// Save digest context in digest cache, we may need it later because of
// subsequest responses to the same req on the same/diff connection
if ((authenticationScheme & AuthenticationSchemes.Digest) != 0)
{
SaveDigestContext(toClose);
}
else
{
toClose.CloseContext();
}
}
}
// Send the 401 here.
if (httpContext == null)
{
SendError(requestId, challenges != null && challenges.Count > 0 ? HttpStatusCode.Unauthorized : HttpStatusCode.Forbidden, challenges);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() SendUnauthorized(Scheme:" + authenticationScheme + ")");
return null;
}
if (!stoleBlob)
{
stoleBlob = true;
httpContext.Request.ReleasePins();
}
return httpContext;
}
catch
{
if (httpContext != null)
{
httpContext.Request.DetachBlob(memoryBlob);
httpContext.Close();
}
if (newContext != null)
{
if (newContext == context)
{
// Prevent the finally from closing this twice.
context = null;
}
if (newContext != oldContext)
{
NTAuthentication toClose = newContext;
newContext = null;
toClose.CloseContext();
}
else
{
newContext = null;
}
}
throw;
}
finally
{
try
{
// Clean up the previous context if necessary.
if (oldContext != null && oldContext != newContext)
{
// Clear out Session if it wasn't already.
if (newContext == null && disconnectResult != null)
{
disconnectResult.Session = null;
}
// Save digest context in digest cache, we may need it later because of
// subsequest responses to the same req on the same/diff connection
if ((authenticationScheme & AuthenticationSchemes.Digest) != 0)
{
SaveDigestContext(oldContext);
}
else
{
oldContext.CloseContext();
}
}
// Delete any context created but not stored.
if (context != null && oldContext != context && newContext != context)
{
context.CloseContext();
}
}
finally
{
// Check if the connection got deleted while in this method, and clear out the hashtables if it did.
// In a nested finally because if this doesn't happen, we leak.
if (disconnectResult != null)
{
disconnectResult.FinishOwningDisconnectHandling();
}
}
}
}
private static void AddChallenge(ref ArrayList challenges, string challenge)
{
if (challenge!=null) {
challenge = challenge.Trim();
if (challenge.Length>0) {
GlobalLog.Print("HttpListener:AddChallenge() challenge:" + challenge);
if (challenges == null)
{
challenges = new ArrayList(4);
}
challenges.Add(challenge);
}
}
}
private ArrayList BuildChallenge(AuthenticationSchemes authenticationScheme, ulong connectionId, out NTAuthentication newContext)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::BuildChallenge() authenticationScheme:" + authenticationScheme.ToString());
ArrayList challenges = null;
newContext = null;
if ((authenticationScheme & AuthenticationSchemes.Negotiate) != 0)
{
AddChallenge(ref challenges, NegotiateClient.AuthType);
}
if ((authenticationScheme & AuthenticationSchemes.Ntlm) != 0)
{
AddChallenge(ref challenges, NtlmClient.AuthType);
}
if ((authenticationScheme & AuthenticationSchemes.Digest) != 0)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::BuildChallenge() package:WDigest");
NTAuthentication context = null;
try
{
context = new NTAuthentication(true, NegotiationInfoClass.WDigest, null, ContextFlags.Connection);
SecurityStatus statusCode;
string outBlob = context.GetOutgoingDigestBlob(null, null, null, Realm, false, false, out statusCode);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::BuildChallenge() GetOutgoingDigestBlob() returned IsCompleted:" + context.IsCompleted + " statusCode:" + statusCode + " outBlob:[" + outBlob + "]");
if (context.IsValidContext)
{
newContext = context;
}
AddChallenge(ref challenges, DigestClient.AuthType + (string.IsNullOrEmpty(outBlob) ? "" : " " + outBlob));
}
finally
{
if (context != null && newContext != context)
{
context.CloseContext();
}
}
}
if ((authenticationScheme & AuthenticationSchemes.Basic) != 0)
{
AddChallenge(ref challenges, BasicClient.AuthType + " realm=\"" + Realm + "\"");
}
return challenges;
}
private void RegisterForDisconnectNotification(ulong connectionId, ref DisconnectAsyncResult disconnectResult)
{
GlobalLog.Assert(disconnectResult == null, "HttpListener#{0}::RegisterForDisconnectNotification()|Called with a disconnectResult.", ValidationHelper.HashString(this));
try
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::RegisterForDisconnectNotification() calling UnsafeNclNativeMethods.HttpApi.HttpWaitForDisconnect");
DisconnectAsyncResult result = new DisconnectAsyncResult(this, connectionId);
EnsureBoundHandle();
uint statusCode = UnsafeNclNativeMethods.HttpApi.HttpWaitForDisconnect(
m_RequestQueueHandle,
connectionId,
result.NativeOverlapped);
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::RegisterForDisconnectNotification() call to UnsafeNclNativeMethods.HttpApi.HttpWaitForDisconnect returned:" + statusCode);
if (statusCode == UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS ||
statusCode == UnsafeNclNativeMethods.ErrorCodes.ERROR_IO_PENDING)
{
// Need to make sure it's going to get returned before adding it to the hash. That way it'll be handled
// correctly in HandleAuthentication's finally.
disconnectResult = result;
DisconnectResults[connectionId] = disconnectResult;
}
}
catch (Win32Exception exception)
{
uint statusCode = (uint) exception.NativeErrorCode;
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::RegisterForDisconnectNotification() call to UnsafeNclNativeMethods.HttpApi.HttpWaitForDisconnect threw. statusCode:" + statusCode);
}
}
private void SendError(ulong requestId, HttpStatusCode httpStatusCode, ArrayList challenges)
{
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::SendInternalError() requestId:" + ValidationHelper.ToString(requestId));
UnsafeNclNativeMethods.HttpApi.HTTP_RESPONSE httpResponse = new UnsafeNclNativeMethods.HttpApi.HTTP_RESPONSE();
httpResponse.Version = new UnsafeNclNativeMethods.HttpApi.HTTP_VERSION();
httpResponse.Version.MajorVersion = (ushort)1;
httpResponse.Version.MinorVersion = (ushort)1;
httpResponse.StatusCode = (ushort)httpStatusCode;
string statusDescription = HttpListenerResponse.GetStatusDescription((int)httpStatusCode);
uint DataWritten = 0;
uint statusCode;
byte[] byteReason = Encoding.Default.GetBytes(statusDescription);
fixed (byte* pReason = byteReason)
{
httpResponse.pReason = (sbyte*)pReason;
httpResponse.ReasonLength = (ushort)byteReason.Length;
byte[] byteContentLength = Encoding.Default.GetBytes("0");
fixed (byte* pContentLength = byteContentLength)
{
(&httpResponse.Headers.KnownHeaders)[(int)HttpResponseHeader.ContentLength].pRawValue = (sbyte*)pContentLength;
(&httpResponse.Headers.KnownHeaders)[(int)HttpResponseHeader.ContentLength].RawValueLength = (ushort)byteContentLength.Length;
httpResponse.Headers.UnknownHeaderCount = checked((ushort) (challenges == null ? 0 : challenges.Count));
GCHandle[] challengeHandles = null;
UnsafeNclNativeMethods.HttpApi.HTTP_UNKNOWN_HEADER[] headersArray = null;
GCHandle headersArrayHandle = new GCHandle();
GCHandle wwwAuthenticateHandle = new GCHandle();
if (httpResponse.Headers.UnknownHeaderCount > 0)
{
challengeHandles = new GCHandle[httpResponse.Headers.UnknownHeaderCount];
headersArray = new UnsafeNclNativeMethods.HttpApi.HTTP_UNKNOWN_HEADER[httpResponse.Headers.UnknownHeaderCount];
}
try
{
if (httpResponse.Headers.UnknownHeaderCount > 0)
{
headersArrayHandle = GCHandle.Alloc(headersArray, GCHandleType.Pinned);
httpResponse.Headers.pUnknownHeaders = (UnsafeNclNativeMethods.HttpApi.HTTP_UNKNOWN_HEADER*) Marshal.UnsafeAddrOfPinnedArrayElement(headersArray, 0);
wwwAuthenticateHandle = GCHandle.Alloc(s_WwwAuthenticateBytes, GCHandleType.Pinned);
sbyte* wwwAuthenticate = (sbyte*) Marshal.UnsafeAddrOfPinnedArrayElement(s_WwwAuthenticateBytes, 0);
for (int i = 0; i < challengeHandles.Length; i++)
{
byte[] byteChallenge = Encoding.Default.GetBytes((string) challenges[i]);
challengeHandles[i] = GCHandle.Alloc(byteChallenge, GCHandleType.Pinned);
headersArray[i].pName = wwwAuthenticate;
headersArray[i].NameLength = (ushort) s_WwwAuthenticateBytes.Length;
headersArray[i].pRawValue = (sbyte*) Marshal.UnsafeAddrOfPinnedArrayElement(byteChallenge, 0);
headersArray[i].RawValueLength = checked((ushort) byteChallenge.Length);
}
}
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::SendInternalError() calling UnsafeNclNativeMethods.HttpApi.HttpSendHtthttpResponse");
statusCode =
UnsafeNclNativeMethods.HttpApi.HttpSendHttpResponse(
m_RequestQueueHandle,
requestId,
0,
&httpResponse,
null,
&DataWritten,
SafeLocalFree.Zero,
0,
null,
null );
}
finally
{
if (headersArrayHandle.IsAllocated)
{
headersArrayHandle.Free();
}
if (wwwAuthenticateHandle.IsAllocated)
{
wwwAuthenticateHandle.Free();
}
if (challengeHandles != null)
{
for (int i = 0; i < challengeHandles.Length; i++)
{
if (challengeHandles[i].IsAllocated)
{
challengeHandles[i].Free();
}
}
}
}
}
}
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::SendInternalError() call to UnsafeNclNativeMethods.HttpApi.HttpSendHttpResponse returned:" + statusCode);
if (statusCode!=UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS) {
// if we fail to send a 401 something's seriously wrong, abort the request
GlobalLog.Print("HttpListener#" + ValidationHelper.HashString(this) + "::HandleAuthentication() SendUnauthorized() returned:" + statusCode);
HttpListenerContext.CancelRequest(m_RequestQueueHandle, requestId);
}
}
internal void CheckDisposed() {
if (m_State==State.Closed) {
throw new ObjectDisposedException(this.GetType().FullName);
}
}
// This only works for context-destroying errors.
private HttpStatusCode HttpStatusFromSecurityStatus(SecurityStatus status)
{
if (NclUtilities.IsCredentialFailure(status))
{
return HttpStatusCode.Unauthorized;
}
if (NclUtilities.IsClientFault(status))
{
return HttpStatusCode.BadRequest;
}
return HttpStatusCode.InternalServerError;
}
enum State {
Stopped,
Started,
Closed,
}
private const int DigestLifetimeSeconds = 300;
private const int MaximumDigests = 1024; // Must be a power of two.
private const int MinimumDigestLifetimeSeconds = 10;
private struct DigestContext
{
internal NTAuthentication context;
internal int timestamp;
}
private DigestContext[] m_SavedDigests;
private ArrayList m_ExtraSavedDigests;
private ArrayList m_ExtraSavedDigestsBaking;
private int m_ExtraSavedDigestsTimestamp;
private int m_NewestContext;
private int m_OldestContext;
private void SaveDigestContext(NTAuthentication digestContext)
{
if (m_SavedDigests == null)
{
Interlocked.CompareExchange(ref m_SavedDigests, new DigestContext[MaximumDigests], null);
}
// We want to actually close the contexts outside the lock.
NTAuthentication oldContext = null;
ArrayList digestsToClose = null;
lock (m_SavedDigests)
{
// If we're stopped, just throw it away.
if (!IsListening)
{
digestContext.CloseContext();
return;
}
int now = ((now = Environment.TickCount) == 0 ? 1 : now);
m_NewestContext = (m_NewestContext + 1) & (MaximumDigests - 1);
int oldTimestamp = m_SavedDigests[m_NewestContext].timestamp;
oldContext = m_SavedDigests[m_NewestContext].context;
m_SavedDigests[m_NewestContext].timestamp = now;
m_SavedDigests[m_NewestContext].context = digestContext;
// May need to move this up.
if (m_OldestContext == m_NewestContext)
{
m_OldestContext = (m_NewestContext + 1) & (MaximumDigests - 1);
}
// Delete additional contexts older than five minutes.
while (unchecked(now - m_SavedDigests[m_OldestContext].timestamp) >= DigestLifetimeSeconds && m_SavedDigests[m_OldestContext].context != null)
{
if (digestsToClose == null)
{
digestsToClose = new ArrayList();
}
digestsToClose.Add(m_SavedDigests[m_OldestContext].context);
m_SavedDigests[m_OldestContext].context = null;
m_OldestContext = (m_OldestContext + 1) & (MaximumDigests - 1);
}
// If the old context is younger than 10 seconds, put it in the backup pile.
if (oldContext != null && unchecked(now - oldTimestamp) <= MinimumDigestLifetimeSeconds * 1000)
{
// Use a two-tier ArrayList system to guarantee each entry lives at least 10 seconds.
if (m_ExtraSavedDigests == null ||
unchecked(now - m_ExtraSavedDigestsTimestamp) > MinimumDigestLifetimeSeconds * 1000)
{
digestsToClose = m_ExtraSavedDigestsBaking;
m_ExtraSavedDigestsBaking = m_ExtraSavedDigests;
m_ExtraSavedDigestsTimestamp = now;
m_ExtraSavedDigests = new ArrayList();
}
m_ExtraSavedDigests.Add(oldContext);
oldContext = null;
}
}
if (oldContext != null)
{
oldContext.CloseContext();
}
if (digestsToClose != null)
{
for (int i = 0; i < digestsToClose.Count; i++)
{
((NTAuthentication)digestsToClose[i]).CloseContext();
}
}
}
private void ClearDigestCache()
{
if (m_SavedDigests == null)
{
return;
}
ArrayList[] toClose = new ArrayList[3];
lock (m_SavedDigests)
{
toClose[0] = m_ExtraSavedDigestsBaking;
m_ExtraSavedDigestsBaking = null;
toClose[1] = m_ExtraSavedDigests;
m_ExtraSavedDigests = null;
m_NewestContext = 0;
m_OldestContext = 0;
toClose[2] = new ArrayList();
for (int i = 0; i < MaximumDigests; i++)
{
if (m_SavedDigests[i].context != null)
{
toClose[2].Add(m_SavedDigests[i].context);
m_SavedDigests[i].context = null;
}
m_SavedDigests[i].timestamp = 0;
}
}
for (int j = 0; j < toClose.Length; j++)
{
if (toClose[j] != null)
{
for (int k = 0; k < toClose[j].Count; k++)
{
((NTAuthentication) toClose[j][k]).CloseContext();
}
}
}
}
class DisconnectAsyncResult : IAsyncResult {
private static readonly IOCompletionCallback s_IOCallback = new IOCompletionCallback(WaitCallback);
private ulong m_ConnectionId;
private HttpListener m_HttpListener;
NativeOverlapped* m_NativeOverlapped;
private int m_OwnershipState; // 0 = normal, 1 = in HandleAuthentication(), 2 = disconnected, 3 = cleaned up
private WindowsPrincipal m_AuthenticatedConnection;
private NTAuthentication m_Session;
internal const string NTLM = "NTLM";
internal NativeOverlapped* NativeOverlapped{
get{
return m_NativeOverlapped;
}
}
public object AsyncState {
get {
throw ExceptionHelper.PropertyNotImplementedException;
}
}
public WaitHandle AsyncWaitHandle {
get {
throw ExceptionHelper.PropertyNotImplementedException;
}
}
public bool CompletedSynchronously {
get {
throw ExceptionHelper.PropertyNotImplementedException;
}
}
public bool IsCompleted {
get {
throw ExceptionHelper.PropertyNotImplementedException;
}
}
internal unsafe DisconnectAsyncResult(HttpListener httpListener, ulong connectionId) {
GlobalLog.Print("DisconnectAsyncResult#" + ValidationHelper.HashString(this) + "::.ctor() httpListener#" + ValidationHelper.HashString(httpListener) + " connectionId:" + connectionId);
m_OwnershipState = 1;
m_HttpListener = httpListener;
m_ConnectionId = connectionId;
Overlapped overlapped = new Overlapped();
overlapped.AsyncResult = this;
// we can call the Unsafe API here, we won't ever call user code
m_NativeOverlapped = overlapped.UnsafePack(s_IOCallback, null);
GlobalLog.Print("DisconnectAsyncResult#" + ValidationHelper.HashString(this) + "::.ctor() overlapped#" + ValidationHelper.HashString(overlapped) + " nativeOverlapped:" + ((IntPtr)m_NativeOverlapped).ToString("x"));
}
internal bool StartOwningDisconnectHandling()
{
int oldValue;
while ((oldValue = Interlocked.CompareExchange(ref m_OwnershipState, 1, 0)) == 2)
{
// Must block until it equals 3 - we must be in the callback right now.
Thread.SpinWait(1);
}
GlobalLog.Assert(oldValue != 1, "DisconnectAsyncResult#{0}::HandleDisconnect()|StartOwningDisconnectHandling() called twice.", ValidationHelper.HashString(this));
return oldValue < 2;
}
internal void FinishOwningDisconnectHandling()
{
// If it got disconnected, run the disconnect code.
if (Interlocked.CompareExchange(ref m_OwnershipState, 0, 1) == 2)
{
HandleDisconnect();
}
}
private static unsafe void WaitCallback(uint errorCode, uint numBytes, NativeOverlapped* nativeOverlapped) {
GlobalLog.Print("DisconnectAsyncResult::WaitCallback() errorCode:" + errorCode + " numBytes:" + numBytes + " nativeOverlapped:" + ((IntPtr)nativeOverlapped).ToString("x"));
// take the DisconnectAsyncResult object from the state
Overlapped callbackOverlapped = Overlapped.Unpack(nativeOverlapped);
DisconnectAsyncResult asyncResult = (DisconnectAsyncResult) callbackOverlapped.AsyncResult;
GlobalLog.Print("DisconnectAsyncResult#" + ValidationHelper.HashString(asyncResult) + "::WaitCallback() callbackOverlapped#" + ValidationHelper.HashString(callbackOverlapped) + " m_ConnectionId:" + asyncResult.m_ConnectionId);
Overlapped.Free(nativeOverlapped);
if (Interlocked.Exchange(ref asyncResult.m_OwnershipState, 2) == 0)
{
asyncResult.HandleDisconnect();
}
}
private void HandleDisconnect()
{
GlobalLog.Print("DisconnectAsyncResult#" + ValidationHelper.HashString(this) + "::HandleDisconnect() DisconnectResults#" + ValidationHelper.HashString(m_HttpListener.DisconnectResults) + " removing for m_ConnectionId:" + m_ConnectionId);
m_HttpListener.DisconnectResults.Remove(m_ConnectionId);
if (m_Session != null)
{
if (m_Session.Package == NegotiationInfoClass.WDigest)
{
// VSWhidbey #497767
// WDigest doesn't like having the context passed back in on the next request on a connection, but it does want
// the server to keep a reference to it for as long as a client might reuse the nonce. The heuristic we use is,
// keep contexts for five minutes, up to a maximum of 1024, except also keep all contexts at least 10 seconds to avoid
// total DoS (where no handshakes can be completed in time).
m_HttpListener.SaveDigestContext(m_Session);
}
else
{
m_Session.CloseContext();
}
}
// Clean up the identity. This is for scenarios where identity was not cleaned up before due to
// identity caching for unsafe ntlm authentication
IDisposable identity = m_AuthenticatedConnection == null ? null : m_AuthenticatedConnection.Identity as IDisposable;
if ((identity != null) &&
(m_AuthenticatedConnection.Identity.AuthenticationType == NTLM) &&
(m_HttpListener.UnsafeConnectionNtlmAuthentication))
{
identity.Dispose();
}
int oldValue = Interlocked.Exchange(ref m_OwnershipState, 3);
GlobalLog.Assert(oldValue == 2, "DisconnectAsyncResult#{0}::HandleDisconnect()|Expected OwnershipState of 2, saw {1}.", ValidationHelper.HashString(this), oldValue);
}
internal WindowsPrincipal AuthenticatedConnection
{
get
{
return m_AuthenticatedConnection;
}
set
{
// The previous value can't be disposed because it may be in use by the app.
m_AuthenticatedConnection = value;
}
}
internal NTAuthentication Session
{
get
{
return m_Session;
}
set
{
m_Session = value;
}
}
}
}
/* Proposed Future HTTP Base Classes
see \ndp\mb\docs\specs\NetworkFramework\HTTPSYS\ASP.NET\stub.cs
// System.Net exposes base abstract classes that System.Web will inherit from
public abstract class BaseHttpContext {
public virtual IPrincipal User { get; set; }
// it doesn't make sense to make these virtual because we can't override
// and change the returned type for System.Web or people would break.
// the only thing we can do is to declare them normally and hide the
// base implementation like "public new System.Web.HttpRequest Request"
public BaseHttpRequest Request { get; }
public BaseHttpResponse Response { get; }
// these provide plumbing to make the above two methods callable with a BaseHttpContext reference
protected virtual BaseHttpRequest GetRequest();
protected virtual BaseHttpResponse GetResponse();
}
public abstract class BaseHttpRequest {
public virtual string[] AcceptTypes { get; }
public virtual Encoding ContentEncoding { get; set; }
public virtual string ContentType { get; set; }
public virtual NameValueCollection Headers { get; }
public virtual string HttpMethod { get; }
public virtual Stream InputStream { get; }
public virtual bool IsAuthenticated { get; }
public virtual bool IsLocal { get; }
public virtual bool IsSecureConnection { get; }
public virtual NameValueCollection QueryString { get; }
public virtual string RawUrl { get; }
public virtual Uri Url { get; }
public virtual Uri UrlReferrer { get; }
public virtual string UserAgent { get; }
public virtual string UserHostAddress { get; }
public virtual string UserHostName { get; }
public virtual string[] UserLanguages { get; }
// APIs that are in the base class but are new to ASP .NET
public virtual long ContentLengthLong { get; }
public virtual bool HasEntityBody { get; }
public virtual bool KeepAlive { get; }
public virtual IPEndPoint RemoteEndPoint { get; }
public virtual IPEndPoint LocalEndPoint { get; }
}
public abstract class BaseHttpResponse {
public virtual void AppendHeader(string name, string value);
public virtual void Close();
public virtual Encoding ContentEncoding { get; set; }
public virtual string ContentType { get; set; }
public virtual Stream OutputStream { get; }
public virtual string RedirectLocation { get; set; }
public virtual int StatusCode { get; set; }
public virtual string StatusDescription { get; set; }
// APIs that are in the base class but are new to ASP .NET
public virtual bool KeepAlive { get; set; }
}
*/
}
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DataGridViewMethods.cs
- CqlLexer.cs
- UdpDuplexChannel.cs
- DocumentXPathNavigator.cs
- WinFormsSecurity.cs
- TypeHelpers.cs
- ServicePoint.cs
- Collection.cs
- DataTablePropertyDescriptor.cs
- WeakReference.cs
- SymbolEqualComparer.cs
- KnownTypesHelper.cs
- connectionpool.cs
- HtmlPanelAdapter.cs
- ImageCodecInfoPrivate.cs
- CounterSample.cs
- ISAPIApplicationHost.cs
- HtmlTextArea.cs
- PipeConnection.cs
- TypeToken.cs
- Effect.cs
- CellConstant.cs
- IPHostEntry.cs
- CapabilitiesAssignment.cs
- SrgsRulesCollection.cs
- SystemWebExtensionsSectionGroup.cs
- CalendarDay.cs
- OdbcConnectionHandle.cs
- RequestSecurityTokenResponse.cs
- BindingGroup.cs
- HashLookup.cs
- ReplyAdapterChannelListener.cs
- NamespaceCollection.cs
- ObjectAnimationBase.cs
- TreeViewHitTestInfo.cs
- XmlDomTextWriter.cs
- CompModSwitches.cs
- Span.cs
- SocketException.cs
- XsltQilFactory.cs
- SubqueryRules.cs
- OrderByExpression.cs
- DrawingGroup.cs
- Rect3DConverter.cs
- ClientConfigurationHost.cs
- SchemaTypeEmitter.cs
- SqlProviderServices.cs
- shaperfactoryquerycacheentry.cs
- CharUnicodeInfo.cs
- CompositionTarget.cs
- DictionaryBase.cs
- Publisher.cs
- TextBox.cs
- DataServiceRequestException.cs
- TextEffectResolver.cs
- ResizeGrip.cs
- WaveHeader.cs
- CodeGotoStatement.cs
- DataServiceException.cs
- DeviceContext2.cs
- BitmapEffectInput.cs
- ListBindableAttribute.cs
- XPathNodeHelper.cs
- GridViewEditEventArgs.cs
- RequestResizeEvent.cs
- IgnoreFileBuildProvider.cs
- BinaryNode.cs
- AsymmetricSignatureFormatter.cs
- ActivationArguments.cs
- SafeNativeMethods.cs
- ScriptComponentDescriptor.cs
- webclient.cs
- CorrelationValidator.cs
- FunctionCommandText.cs
- IndependentAnimationStorage.cs
- RegistryExceptionHelper.cs
- RichTextBoxConstants.cs
- EventSetter.cs
- WriterOutput.cs
- ClassGenerator.cs
- CodeExporter.cs
- PolicyLevel.cs
- FactoryRecord.cs
- GridViewColumnHeader.cs
- CompatibleComparer.cs
- Hash.cs
- ErrorInfoXmlDocument.cs
- WinCategoryAttribute.cs
- DataReceivedEventArgs.cs
- DelegateSerializationHolder.cs
- DataGridViewRowCollection.cs
- SerialPort.cs
- CheckBoxRenderer.cs
- SecurityTokenSerializer.cs
- ServicePoint.cs
- Sql8ExpressionRewriter.cs
- ControlEvent.cs
- SystemWebExtensionsSectionGroup.cs
- RuleSettingsCollection.cs
- SmiConnection.cs