mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
1027 lines
43 KiB
C#
1027 lines
43 KiB
C#
//------------------------------------------------------------
|
|
// 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;
|
|
}
|
|
}
|
|
}
|