//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Activation
{
    using System.Diagnostics;
    using System.Globalization;
    using System.IO;
    using System.Net;
    using System.Runtime;
    using System.Runtime.Diagnostics;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Security;
    using System.Security.Authentication.ExtendedProtection;
    using System.Security.Cryptography.X509Certificates;
    using System.Security.Permissions;
    using System.Security.Principal;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Activation.Configuration;
    using System.ServiceModel.Activation.Diagnostics;
    using System.Threading;
    using System.Web;
    using System.Web.Management;
    using System.Web.Routing;
    using TD2 = System.ServiceModel.Diagnostics.Application.TD;

    class HostedHttpRequestAsyncResult : AsyncResult, HttpChannelListener.IHttpAuthenticationContext
    {
        [Fx.Tag.SecurityNote(Critical = "Stores the securitycritical callback values, we need to protect these values")]
        [SecurityCritical]
        static WindowsIdentity anonymousIdentity;
        [SecurityCritical]
        static Action<object> waitOnBeginRequest;
        [SecurityCritical]
        static Action<object> waitOnBeginRequestWithFlow;
        [SecurityCritical]
        static ContextCallback contextOnBeginRequest;
        [SecurityCritical]
        static AsyncCallback processRequestCompleteCallback;


        [ThreadStatic]
        static AutoResetEvent waitObject;

        static Nullable<bool> iisSupportsExtendedProtection;

        [Fx.Tag.SecurityNote(Critical = "Keeps track of impersonated user, caller must use with care")]
        [SecurityCritical]
        HostedImpersonationContext impersonationContext;

        [Fx.Tag.SecurityNote(Critical = "Keeps track of thread static data (HttpContext, CurrentCulture, CurrentUICulture) that is used for AspNetCompatibility mode, caller must use with care")]
        [SecurityCritical]
        HostedThreadData hostedThreadData;

        [Fx.Tag.SecurityNote(Critical =
            "This field is used to manipulate request/responses using APIs protected by LinkDemand." +
            "It is critical because we use it to determine whether we believe we're being hosted in ASP.NET or not." +
            "The field is set in the constructor of this class and we deem it safe because:" +
            "    1) all paths that lead to the .ctor are SecurityCritical and" +
            "    2) those paths have called ServiceHostingEnvironment.EnsureInitialized (which is also critical)" +
            "So if the field is non-null, it's safe to say that we're hosted in ASP.NET, hence all the helper methods in this class that touch this field can be SecurityTreatAsSafe")]
        [SecurityCritical]
        HttpApplication context;

        int state;

        int streamedReadState;

        [Fx.Tag.SecurityNote(Critical = "Determines whether to set the HttpContext on the outgoing thread.")]
        [SecurityCritical]
        bool flowContext;
        bool ensureWFService;
        string configurationBasedServiceVirtualPath;
        EventTraceActivity eventTraceActivity;

        readonly bool isWebSocketRequest;

        [Fx.Tag.SecurityNote(Critical = "Captures HostedImpersonationContext which must be done in the right place, and calls unsafe" +
        "ScheduleCallbackLowPriNoFlow and ScriptTimeout.  Called outside of user security context.")]
        [SecurityCritical]
        public HostedHttpRequestAsyncResult(HttpApplication context, bool flowContext, bool ensureWFService, AsyncCallback callback, object state) :
            this(context, null, flowContext, ensureWFService, callback, state)
        {
        }

        [Fx.Tag.SecurityNote(Critical = "Captures HostedImpersonationContext which must be done in the right place, and calls unsafe" +
            "ScheduleCallbackLowPriNoFlow and ScriptTimeout.  Called outside of user security context.")]
        [SecurityCritical]
        public HostedHttpRequestAsyncResult(HttpApplication context, string aspNetRouteServiceVirtualPath, bool flowContext, bool ensureWFService, AsyncCallback callback, object state) :
            base(callback, state)
        {
            if (context == null)
            {
                throw FxTrace.Exception.ArgumentNull("context");
            }

            AspNetPartialTrustHelpers.FailIfInPartialTrustOutsideAspNet();

            HostedAspNetEnvironment.TrySetWebSocketVersion(context);
            this.context = context;
            // WebSockets require the integrated pipeline mode and the WebSocket IIS module to be loaded. If these conditions 
            // are not met, the HttpContext.IsWebSocketRequest property throws. Also, if these conditions are not met,
            // we do not let WebSocket listeners to be started (we fail the service activation), so setting the 'isWebSocketRequest' flag 
            // to false in this case will not create confusion (or make troubleshooting difficult).
            this.isWebSocketRequest = HttpRuntime.UsingIntegratedPipeline && AspNetEnvironment.Current.IsWebSocketModuleLoaded && this.context.Context.IsWebSocketRequest;
            this.flowContext = flowContext;
            if (ensureWFService)
            {
                // check for CBA scenario. if true, service should be handled by WCF instead of WF, 
                // set this.ensureWFservice to false
                if (ServiceHostingEnvironment.IsConfigurationBasedService(context, out this.configurationBasedServiceVirtualPath))
                {
                    this.ensureWFService = false;
                }
                else
                {
                    this.ensureWFService = true;
                }
            }

            if (!string.IsNullOrEmpty(aspNetRouteServiceVirtualPath))
            {
                // aspnet routing can hijack CBA request as we append {*pathInfo} to urlpattern and there is no real file for CBA 
                // check for CBA scenario. if the request is hijacked. i.e., 
                // 1) route maps to a virtual directory:
                // aspNetRouteServiceVirtualPath <> context.Request.AppRelativeCurrentExecutionFilePath == configurationBasedServiceVirtualPath 
                // if RouteExistingFiles <> true, set aspnetRouteServiceVirtualPath to null so that the request will be treated as CBA
                // if RouteExistingFiles == true, this hijack is by-design, do nothing
                // 2) route maps to a CBA entry:
                // aspNetRouteServiceVirtualPath == context.Request.AppRelativeCurrentExecutionFilePath == configurationBasedServiceVirtualPath
                // we will use RouteExistingFiles to decide which service should be activated. We do it in ServiceHostingEnviroment.HostingManager, 
                // as we cannot pass this info to the latter. 
                if (!RouteTable.Routes.RouteExistingFiles &&
                    ServiceHostingEnvironment.IsConfigurationBasedService(context, out this.configurationBasedServiceVirtualPath))
                {
                    this.AspNetRouteServiceVirtualPath = null;
                }
                else
                {
                    this.AspNetRouteServiceVirtualPath = aspNetRouteServiceVirtualPath;
                }
            }

            // If this is a DEBUG request, complete right away and let ASP.NET handle it.
            string method = context.Request.HttpMethod ?? "";
            char firstMethodChar = method.Length == 5 ? method[0] : '\0';
            if ((firstMethodChar == 'd' || firstMethodChar == 'D') &&
                string.Compare(method, "DEBUG", StringComparison.OrdinalIgnoreCase) == 0)
            {
                if (DiagnosticUtility.ShouldTraceVerbose)
                {
                    TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.WebHostDebugRequest, SR.TraceCodeWebHostDebugRequest, this);
                }

                this.state = State.Completed;
                Complete(true, null);
                return;
            }

            this.impersonationContext = new HostedImpersonationContext();

            if (flowContext)
            {
                if (ServiceHostingEnvironment.AspNetCompatibilityEnabled)
                {
                    // Capture HttpContext/culture context if necessary.  Can be used later by HostedHttpInput to re-apply
                    // the culture during dispatch.  Also flowed here.
                    hostedThreadData = new HostedThreadData();
                }
            }

            // Set this up before calling IncrementRequestCount so if it fails, we don't leak a count.
            Action<object> iotsCallback = (AspNetPartialTrustHelpers.NeedPartialTrustInvoke || flowContext) ?
                WaitOnBeginRequestWithFlow : WaitOnBeginRequest;

            // Tell ASPNET to by-pass all the other events so no other http modules will
            // be invoked, Indigo basically takes over the request completely. This should
            // only be called in non-AspNetCompatibilityEnabled mode.
            if (!ServiceHostingEnvironment.AspNetCompatibilityEnabled && !this.ensureWFService)
            {
                context.CompleteRequest();
            }

            // Prevent ASP.NET from generating thread aborts in relation to this request.
            context.Server.ScriptTimeout = int.MaxValue;

            ServiceHostingEnvironment.IncrementRequestCount(ref this.eventTraceActivity, context.Request.AppRelativeCurrentExecutionFilePath);

            IOThreadScheduler.ScheduleCallbackLowPriNoFlow(iotsCallback, this);
        }

        public static WindowsIdentity AnonymousIdentity
        {
            [Fx.Tag.SecurityNote(Critical = "Access the value of corresponding static field and prevent someone from changing its value")]
            [SecuritySafeCritical]
            get
            {
                if (anonymousIdentity == null)
                {
                    anonymousIdentity = WindowsIdentity.GetAnonymous();
                }
                return anonymousIdentity;
            }
        }

        public static Action<object> WaitOnBeginRequest
        {
            [Fx.Tag.SecurityNote(Critical = "Access the value of corresponding static field and prevent someone from changing its value")]
            [SecuritySafeCritical]
            get
            {
                if (waitOnBeginRequest == null)
                {
                    waitOnBeginRequest = new Action<object>(OnBeginRequest);
                }
                return waitOnBeginRequest;
            }
        }

        public static Action<object> WaitOnBeginRequestWithFlow
        {
            [Fx.Tag.SecurityNote(Critical = "Access the value of corresponding static field and prevent someone from changing its value")]
            [SecuritySafeCritical]
            get
            {
                if (waitOnBeginRequestWithFlow == null)
                {
                    waitOnBeginRequestWithFlow = new Action<object>(OnBeginRequestWithFlow);
                }
                return waitOnBeginRequestWithFlow;
            }
        }

        public static ContextCallback ContextOnBeginRequest
        {
            [Fx.Tag.SecurityNote(Critical = "Access the value of corresponding static field and prevent someone from changing its value")]
            [SecuritySafeCritical]
            get
            {
                if (contextOnBeginRequest == null)
                {
                    contextOnBeginRequest = new ContextCallback(OnBeginRequest);
                }
                return contextOnBeginRequest;
            }
        }

        public static AsyncCallback ProcessRequestCompleteCallback
        {
            [Fx.Tag.SecurityNote(Critical = "Access the value of corresponding static field and prevent someone from changing its value")]
            [SecuritySafeCritical]
            get
            {
                if (processRequestCompleteCallback == null)
                {
                    processRequestCompleteCallback = Fx.ThunkCallback(new AsyncCallback(ProcessRequestComplete));
                }
                return processRequestCompleteCallback;
            }
        }

        public bool IISSupportsExtendedProtection
        {
            get
            {
                if (HostedHttpRequestAsyncResult.iisSupportsExtendedProtection == null)
                {
                    HostedHttpRequestAsyncResult.iisSupportsExtendedProtection = this.IISSupportsExtendedProtectionInternal();
                }
                return HostedHttpRequestAsyncResult.iisSupportsExtendedProtection.Value;
            }
        }

        public bool IsWebSocketRequest
        {
            get { return this.isWebSocketRequest; }
        }

        [Fx.Tag.SecurityNote(Critical = "Touches critical field context.", Safe = "Does not leak control or data, no potential for harm.")]
        [SecuritySafeCritical]
        [MethodImpl(MethodImplOptions.NoInlining)]
        [PermissionSetAttribute(SecurityAction.Assert, Unrestricted = true)]
        private bool IISSupportsExtendedProtectionInternal()
        {
            DiagnosticUtility.DebugAssert(ExtendedProtectionPolicy.OSSupportsExtendedProtection, "OS must support ExtendedProtection");

            try
            {
                ChannelBinding cbt = this.context.Request.HttpChannelBinding;
                return true;
            }
            catch (PlatformNotSupportedException)
            {
                // contract with Asp.Net is that they will always throw a PlatformNotSupportedException if IIS is not patched for CBT yet
                return false;
            }
            catch (COMException)
            {
                // If IIS is patched for CBT and an error occurs when trying to retrieve the token a COMException is thrown. Even in this
                // case we know that IIS is patched for CBT.
                return true;
            }
        }


        [Fx.Tag.SecurityNote(Critical = "Captures HostedImpersonationContext which must be done in the right place, and calls unsafe" +
            "ScheduleCallbackLowPriNoFlow and ScriptTimeout.  Called outside of user security context." +
            "Callers of this function must call ServiceHostingEnvironment.EnsureInitialized")]
        [SecurityCritical]
        public static void ExecuteSynchronous(HttpApplication context, bool flowContext, bool ensureWFService)
        {
            ExecuteSynchronous(context, null, flowContext, ensureWFService);
        }

        [Fx.Tag.SecurityNote(Critical = "Captures HostedImpersonationContext which must be done in the right place, and calls unsafe" +
            "ScheduleCallbackLowPriNoFlow and ScriptTimeout.  Called outside of user security context." +
            "Callers of this function must call ServiceHostingEnvironment.EnsureInitialized")]
        [SecurityCritical]
        public static void ExecuteSynchronous(HttpApplication context, string routeServiceVirtualPath, bool flowContext, bool ensureWFService)
        {
            AutoResetEvent wait = HostedHttpRequestAsyncResult.waitObject;
            if (wait == null)
            {
                wait = new AutoResetEvent(false);
                HostedHttpRequestAsyncResult.waitObject = wait;
            }

            HostedHttpRequestAsyncResult result;
            try
            {
                result = new HostedHttpRequestAsyncResult(context, routeServiceVirtualPath, flowContext, ensureWFService, ProcessRequestCompleteCallback, wait);
                if (!result.CompletedSynchronously)
                {
                    wait.WaitOne();
                }
                wait = null;
            }
            finally
            {
                if (wait != null)
                {
                    // Not sure of the state anymore.
                    HostedHttpRequestAsyncResult.waitObject = null;
                    wait.Close();
                }
            }

            HostedHttpRequestAsyncResult.End(result);
        }

        [Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - Can be called outside of a user context.")]
        static void ProcessRequestComplete(IAsyncResult result)
        {
            if (!result.CompletedSynchronously)
            {
                try
                {
                    ((AutoResetEvent)result.AsyncState).Set();
                }
                catch (ObjectDisposedException exception)
                {
                    DiagnosticUtility.TraceHandledException(exception, TraceEventType.Warning);
                }
            }
        }

        [Fx.Tag.SecurityNote(Critical = "Can be called outside of user context, accesses hostedThreadData.",
            Safe = "Uses hostedThreadData to set HttpContext.Current, cultures to the one attached to this async-result instance.")]
        [SecuritySafeCritical]
        static void OnBeginRequestWithFlow(object state)
        {
            HostedHttpRequestAsyncResult self = (HostedHttpRequestAsyncResult)state;

            IDisposable hostedThreadContext = null;
            try
            {
                if (self.flowContext)
                {
                    // In AspCompat case, these are the three things that need to be flowed.  See HostedHttpInput.
                    if (self.hostedThreadData != null)
                    {
                        hostedThreadContext = self.hostedThreadData.CreateContext();
                    }
                }

                // In full-trust, this simply calls the delegate.
                AspNetPartialTrustHelpers.PartialTrustInvoke(ContextOnBeginRequest, self);
            }
            finally
            {
                if (hostedThreadContext != null)
                {
                    hostedThreadContext.Dispose();
                }
            }
        }

        static void OnBeginRequest(object state)
        {
            HostedHttpRequestAsyncResult self = (HostedHttpRequestAsyncResult)state;

            Exception completionException = null;
            try
            {
                self.BeginRequest();
            }
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                {
                    throw;
                }

                completionException = e;
            }

            if (completionException != null)
            {
                self.CompleteOperation(completionException);
            }
        }

        void BeginRequest()
        {
            try
            {
                HandleRequest();
            }
            catch (EndpointNotFoundException exception)
            {
                // HTTP-GET is special cased to avoid that the ServiceActivation-HTTP-response is treated as service response.
                // For WebSocket requests we treat the ServiceActivation in the same way like for SOAP (HTTP-POST) requests.
                if (string.Compare(GetHttpMethod(), "GET", StringComparison.OrdinalIgnoreCase) == 0 &&
                    !this.isWebSocketRequest)
                {
                    // Wrap the exception into HttpException
                    throw FxTrace.Exception.AsError(new HttpException((int)HttpStatusCode.NotFound, exception.Message, exception));
                }

                SetStatusCode((int)HttpStatusCode.NotFound);
                CompleteOperation(null);
            }
            catch (ServiceActivationException exception)
            {
                // HTTP-GET is special cased to avoid that the ServiceActivation-HTTP-response is treated as service response.
                // For WebSocket requests we treat the ServiceActivation in the same way like for SOAP (HTTP-POST) requests.
                if (string.Compare(GetHttpMethod(), "GET", StringComparison.OrdinalIgnoreCase) == 0 &&
                    !this.isWebSocketRequest)
                {
                    if (exception.InnerException is HttpException)
                    {
                        throw exception.InnerException;
                    }
                    else
                    {
                        throw;
                    }
                }

                SetStatusCode((int)HttpStatusCode.InternalServerError);
                SetStatusDescription(
                    HttpChannelUtilities.StatusDescriptionStrings.HttpStatusServiceActivationException);
                CompleteOperation(null);
            }
            finally
            {
                ReleaseImpersonation();
            }
        }

        public WindowsIdentity LogonUserIdentity
        {
            get
            {
                IPrincipal user = this.Application.User;
                if (user == null)
                {
                    return AnonymousIdentity;
                }

                WindowsIdentity identity = user.Identity as WindowsIdentity;
                if (identity == null)
                {
                    return AnonymousIdentity;
                }

                return identity;
            }
        }

        WindowsIdentity HttpChannelListener.IHttpAuthenticationContext.LogonUserIdentity
        {
            get
            {
                return this.LogonUserIdentity;
            }
        }

        public HostedImpersonationContext ImpersonationContext
        {
            [Fx.Tag.SecurityNote(Critical = "Keeps track of impersonated user, caller must use with care.",
                Safe = "Safe for Get, individual members of HostedImpersonationContext are protected.")]
            [SecuritySafeCritical]
            get
            {
                return this.impersonationContext;
            }
        }

        public HostedThreadData HostedThreadData
        {
            [Fx.Tag.SecurityNote(Critical = "Keeps track of impersonated user, caller must use with care.",
                Safe = "Safe for Get, individual members of HostedThreadData are protected.")]
            [SecuritySafeCritical]
            get
            {
                return this.hostedThreadData;
            }
        }

        public EventTraceActivity EventTraceActivity
        {
            get
            {
                return this.eventTraceActivity;
            }
        }

        public Uri OriginalRequestUri
        {
            get;
            private set;

        }

        public Uri RequestUri
        {
            get;
            private set;
        }

        public HttpApplication Application
        {
            [Fx.Tag.SecurityNote(Critical = "Touches critical field context.", Safe = "Does not leak control or data, no potential for harm.")]
            [SecuritySafeCritical]
            get
            {
                return this.context;
            }
        }

        public string AspNetRouteServiceVirtualPath
        {
            get;
            private set;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.", Safe = "Does not leak control or data, no potential for harm.")]
        [SecuritySafeCritical]
        public Stream GetInputStream()
        {
            try
            {
                // CSDMain #133228: "Consume GetBufferlessInputStream"
                // The ReadEntityBodyMode property on the HttpRequest keeps track of whether the request stream has already been accessed, and if so, what API was used to access the request.
                //     - "None" means that the request stream hasn't been accessed.
                //     - "Bufferless" means that GetBufferlessInputStream() was used to access it.
                //     - "Buffered" means GetBufferedInputStream() was used to access it.
                //     - "Classic" means that either the InputStream, Form, Files, or BinaryRead APIs were invoked already.
                // In general, these values are incompatible with one another, meaning that once the request was accessed in a "Classic" way, only "Classic" APIs can be invoked on the HttpRequest.
                // If incompatible APIs are invoked, an HttpException is thrown.
                // In order to prevent HttpExceptions from being thrown for this reason, we will check the ReadEntityBodyMode, and access the request stream with the corresponding API
                // If the request stream hasn't been accessed yet (eg, by an HttpModule which executed earlier), then we will use GetBufferlessInputStream by default.
                ReadEntityBodyMode mode = this.context.Request.ReadEntityBodyMode;
                Fx.Assert(mode == ReadEntityBodyMode.None || mode == ReadEntityBodyMode.Bufferless || mode == ReadEntityBodyMode.Buffered || mode == ReadEntityBodyMode.Classic,
                    "Unknown value for System.Web.ReadEntityBodyMode enum");

                if (mode == ReadEntityBodyMode.None && ServiceHostingEnvironment.AspNetCompatibilityEnabled && AppSettings.UseClassicReadEntityMode)
                {
                    mode = ReadEntityBodyMode.Classic;
                }

                switch (mode)
                {
                    case ReadEntityBodyMode.None:
                    case ReadEntityBodyMode.Bufferless:
                        return this.context.Request.GetBufferlessInputStream(true);  // ignores system.web/httpRuntime/maxRequestLength
                    case ReadEntityBodyMode.Buffered:
                        return this.context.Request.GetBufferedInputStream();
                    default: 
                        // ReadEntityBodyMode.Classic:
                        return this.context.Request.InputStream;
                }
            }
            catch (HttpException hostedException)
            {
                if (hostedException.WebEventCode == WebEventCodes.RuntimeErrorPostTooLarge)
                {
                    throw FxTrace.Exception.AsError(HttpInput.CreateHttpProtocolException(SR.Hosting_MaxRequestLengthExceeded, HttpStatusCode.RequestEntityTooLarge, null, hostedException));
                }
                else
                {
                    throw FxTrace.Exception.AsError(new CommunicationException(hostedException.Message, hostedException));
                }
            }
        }

        public void OnReplySent()
        {
            CompleteOperation(null);
        }

        internal void CompleteOperation(Exception exception)
        {
            if (this.state == State.Running &&
                Interlocked.CompareExchange(ref this.state, State.Completed, State.Running) == State.Running)
            {
                this.CompleteAsynchronously(exception);
            }
        }

        public void Abort()
        {
            if (this.state == State.Running &&
                Interlocked.CompareExchange(ref this.state, State.Aborted, State.Running) == State.Running)
            {
                int currentStreamedReadState = Interlocked.Exchange(ref this.streamedReadState, StreamedReadState.AbortStarted);
                // Closes the socket connection to the client
                if (HttpRuntime.UsingIntegratedPipeline)
                {
                    Application.Request.Abort();
                }
                else
                {
                    Application.Response.Close();
                }

                if (currentStreamedReadState == StreamedReadState.None)
                {
                    this.CompleteAsynchronously(null);
                }
                else
                {
                    Fx.Assert(currentStreamedReadState == StreamedReadState.ReceiveStarted, string.Format(CultureInfo.InvariantCulture, "currentStramedReadState is not ReceivedStarted: {0}", currentStreamedReadState));
                    if (Interlocked.CompareExchange(ref this.streamedReadState, StreamedReadState.Aborted, StreamedReadState.AbortStarted) == StreamedReadState.AbortStarted)
                    {
                        return;
                    }

                    Fx.Assert(this.streamedReadState == StreamedReadState.ReceiveFinishedAfterAbortStarted, string.Format(CultureInfo.InvariantCulture, "currentStramedReadState is not ReceiveFinished: {0}", this.streamedReadState));
                    this.CompleteAsynchronously(null);
                }
            }
        }

        void CompleteAsynchronously(Exception ex)
        {
            Complete(false, ex);
            ServiceHostingEnvironment.DecrementRequestCount(this.eventTraceActivity);
        }

        internal bool TryStartStreamedRead()
        {
            return Interlocked.CompareExchange(ref this.streamedReadState, StreamedReadState.ReceiveStarted, StreamedReadState.None) == StreamedReadState.None;
        }

        internal void SetStreamedReadFinished()
        {
            if (Interlocked.CompareExchange(ref this.streamedReadState, StreamedReadState.None, StreamedReadState.ReceiveStarted) == StreamedReadState.ReceiveStarted)
            {
                return;
            }

            if (Interlocked.CompareExchange(ref this.streamedReadState, StreamedReadState.ReceiveFinishedAfterAbortStarted, StreamedReadState.AbortStarted) == StreamedReadState.AbortStarted)
            {
                return;
            }

            Fx.Assert(this.streamedReadState == StreamedReadState.Aborted, string.Format(CultureInfo.InvariantCulture, "currentStramedReadState is not Aborted: {0}", this.streamedReadState));

            this.CompleteAsynchronously(null);
        }

        [Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - Can be called outside of a user context.")]
        public static void End(IAsyncResult result)
        {
            try
            {
                AsyncResult.End<HostedHttpRequestAsyncResult>(result);
            }
            catch (Exception exception)
            {
                if (!Fx.IsFatal(exception))
                {
                    // Log the exception.
                    DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error, (ushort)System.Runtime.Diagnostics.EventLogCategory.WebHost, 
                        (uint)System.Runtime.Diagnostics.EventLogEventId.WebHostFailedToProcessRequest,
                      TraceUtility.CreateSourceString(result),
                      exception == null ? string.Empty : exception.ToString());
                }
                throw;
            }
        }

        X509Certificate2 HttpChannelListener.IHttpAuthenticationContext.GetClientCertificate(out bool isValidCertificate)
        {
            HttpClientCertificate certificateInfo = this.Application.Request.ClientCertificate;
            isValidCertificate = certificateInfo.IsValid;
            if (certificateInfo.IsPresent)
            {
                return new X509Certificate2(certificateInfo.Certificate);
            }
            else
            {
                return null;
            }
        }

        TraceRecord HttpChannelListener.IHttpAuthenticationContext.CreateTraceRecord()
        {
            return new System.ServiceModel.Diagnostics.HttpRequestTraceRecord(this.Application.Request);
        }

        void HandleRequest()
        {
            this.OriginalRequestUri = GetUrl();
            string relativeVirtualPath;
            if (!string.IsNullOrEmpty(this.AspNetRouteServiceVirtualPath))
            {
                relativeVirtualPath = this.AspNetRouteServiceVirtualPath;
            }
            else if (!string.IsNullOrEmpty(this.configurationBasedServiceVirtualPath))
            {
                relativeVirtualPath = this.configurationBasedServiceVirtualPath;

            }
            else
            {
                relativeVirtualPath = GetAppRelativeCurrentExecutionFilePath();
            }

            if (ensureWFService)
            {
                bool bypass = false;
                try
                {
                    if (!ServiceHostingEnvironment.EnsureWorkflowService(relativeVirtualPath))
                    {
                        CompleteOperation(null);
                        bypass = true;
                        return;
                    }
                }
                finally
                {
                    if (!bypass)
                    {
                        CompleteRequest();
                    }
                }
            }

            // Support for Cassini.
            if (ServiceHostingEnvironment.IsSimpleApplicationHost)
            {
                HostedTransportConfigurationManager.EnsureInitializedForSimpleApplicationHost(this);
            }

            HttpHostedTransportConfiguration transportConfiguration = HostedTransportConfigurationManager.GetConfiguration(this.OriginalRequestUri.Scheme)
                as HttpHostedTransportConfiguration;
            HostedHttpTransportManager transportManager = null;

            // There must be a transport binding that matches the request.
            if (transportConfiguration != null)
            {
                transportManager = transportConfiguration.GetHttpTransportManager(this.OriginalRequestUri);
            }

            if (transportManager == null)
            {
                InvalidOperationException invalidOpException = new InvalidOperationException(SR.Hosting_TransportBindingNotFound(OriginalRequestUri.ToString()));

                ServiceActivationException activationException = new ServiceActivationException(invalidOpException.Message, invalidOpException);

                LogServiceActivationException(activationException);

                throw FxTrace.Exception.AsError(activationException);
            }

            this.RequestUri = new Uri(transportManager.ListenUri, this.OriginalRequestUri.PathAndQuery);
            Fx.Assert(
                object.ReferenceEquals(this.RequestUri.Scheme, Uri.UriSchemeHttp) || object.ReferenceEquals(this.RequestUri.Scheme, Uri.UriSchemeHttps),
                "Scheme must be Http or Https.");

            ServiceHostingEnvironment.EnsureServiceAvailableFast(relativeVirtualPath, this.eventTraceActivity);

            transportManager.HttpContextReceived(this);
        }

        [Fx.Tag.SecurityNote(Critical = "Calls into an unsafe UnsafeLogEvent method",
            Safe = "Event identities cannot be spoofed as they are constants determined inside the method")]
        [SecuritySafeCritical]
        void LogServiceActivationException(ServiceActivationException activationException)
        {
            if (TD2.ServiceExceptionIsEnabled())
            {
                TD2.ServiceException(this.eventTraceActivity, activationException.ToString(), typeof(ServiceActivationException).FullName);
            }

            if (TD.ServiceActivationExceptionIsEnabled())
            {
                TD.ServiceActivationException(activationException != null ? activationException.ToString() : string.Empty, activationException);
            }
            DiagnosticUtility.UnsafeEventLog.UnsafeLogEvent(TraceEventType.Error, (ushort)System.Runtime.Diagnostics.EventLogCategory.WebHost, 
                (uint)System.Runtime.Diagnostics.EventLogEventId.WebHostFailedToProcessRequest, true,
                    TraceUtility.CreateSourceString(this), activationException.ToString());
        }

        [Fx.Tag.SecurityNote(Critical = "manipulates impersonation object",
           Safe = "Does not leak control or mutable/harmful data, no potential for harm except memory leak.")]
        [SecuritySafeCritical]
        internal void AddRefForImpersonation()
        {
            if (this.impersonationContext != null)
            {
                this.impersonationContext.AddRef();
            }
        }

        [Fx.Tag.SecurityNote(Critical = "manipulates impersonation object",
            Safe = "Releasing the SafeHandle early could only cause a future impersonation attempt to fail. We have to handle impersonation failures well already.")]
        [SecuritySafeCritical]
        internal void ReleaseImpersonation()
        {
            if (this.impersonationContext != null)
            {
                this.impersonationContext.Release();
            }
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetContentType(string contentType)
        {
            this.context.Response.ContentType = contentType;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetContentEncoding(string contentEncoding)
        {
            this.context.Response.AddHeader(HttpChannelUtilities.ContentEncodingHeader, contentEncoding);
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, completes the request.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void CompleteRequest()
        {
            this.context.CompleteRequest();
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetTransferModeToStreaming()
        {
            this.context.Response.BufferOutput = false;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void AppendHeader(string name, string value)
        {
            this.context.Response.AppendHeader(name, value);
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetStatusCode(int statusCode)
        {
            this.context.Response.TrySkipIisCustomErrors = true;
            this.context.Response.StatusCode = statusCode;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetStatusDescription(string statusDescription)
        {
            this.context.Response.StatusDescription = statusDescription;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects, changes properties of the HTTP response.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal void SetConnectionClose()
        {
            this.context.Response.AppendHeader("Connection", "close");
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal byte[] GetPrereadBuffer(ref int contentLength)
        {
            byte[] preReadBuffer = new byte[1];
            if (this.GetInputStream().Read(preReadBuffer, 0, 1) > 0)
            {
                contentLength = -1;
                return preReadBuffer;
            }
            return null;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal Stream GetOutputStream()
        {
            return this.context.Response.OutputStream;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal string GetHttpMethod()
        {
            return this.context.Request.HttpMethod;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal string GetContentType()
        {
            const string ContentTypeHeaderName = "Content-Type";
            return this.context.Request.Headers[ContentTypeHeaderName];
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal string GetAcceptEncoding()
        {
            return this.context.Request.Headers[HttpChannelUtilities.AcceptEncodingHeader];
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal string GetContentTypeFast()
        {
            return this.context.Request.ContentType;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal int GetContentLength()
        {
            return this.context.Request.ContentLength;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal string GetSoapAction()
        {
            const string SoapActionHeaderName = "SOAPAction";
            return this.context.Request.Headers[SoapActionHeaderName];
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        internal ChannelBinding GetChannelBinding()
        {
            if (!this.IISSupportsExtendedProtection)
            {
                return null;
            }

            return this.context.Request.HttpChannelBinding;
        }


        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        string GetAppRelativeCurrentExecutionFilePath()
        {
            return this.context.Request.AppRelativeCurrentExecutionFilePath;
        }

        [Fx.Tag.SecurityNote(Critical = "Calls getters with LinkDemands in ASP .NET objects.",
            Safe = "Does not leak control or mutable/harmful data, no potential for harm.")]
        [SecuritySafeCritical]
        Uri GetUrl()
        {
            return this.context.Request.Url;
        }

        static class State
        {
            internal const int Running = 0;
            internal const int Completed = 1;
            internal const int Aborted = 2;
        }

        static class StreamedReadState
        {
            internal const int None = 0;
            internal const int ReceiveStarted = 1;
            internal const int ReceiveFinishedAfterAbortStarted = 2;
            internal const int AbortStarted = 3;
            internal const int Aborted = 4;
        }
    }
}