internal ConfigErrorFormatter(System.Configuration.ConfigurationException e)
: base(e.Filename, null, e.Line)
{
_e = e;
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_PRE_PROCESSING);
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);
_message = e.BareMessage;
}
internal ConfigErrorFormatter(ConfigurationException e) : base(null, e.Filename, null, e.Line)
{
this._adaptiveMiscContent = new StringCollection();
this._e = e;
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_PRE_PROCESSING);
PerfCounters.IncrementCounter(AppPerfCounter.ERRORS_TOTAL);
this._message = HttpUtility.FormatPlainTextAsHtml(e.BareMessage);
this._adaptiveMiscContent.Add(this._message);
}
// ctor used in HttpRuntime
internal HttpContext(HttpWorkerRequest wr, bool initResponseWriter)
{
_wr = wr;
Init(new HttpRequest(wr, this), new HttpResponse(wr, this));
if (initResponseWriter)
{
_response.InitResponseWriter();
}
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING);
}
private HttpWorkerRequest DequeueRequest(bool localOnly)
{
HttpWorkerRequest wr = null;
while (_count > 0)
{
lock (this) {
if (_localQueue.Count > 0)
{
wr = (HttpWorkerRequest)_localQueue.Dequeue();
_count--;
}
else if (!localOnly && _externQueue.Count > 0)
{
wr = (HttpWorkerRequest)_externQueue.Dequeue();
_count--;
}
}
if (wr == null)
{
break;
}
else
{
PerfCounters.DecrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.DecrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_DEQUEUED, wr);
}
if (!CheckClientConnected(wr))
{
HttpRuntime.RejectRequestNow(wr, true);
wr = null;
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_DISCONNECTED);
PerfCounters.IncrementCounter(AppPerfCounter.APP_REQUEST_DISCONNECTED);
}
else
{
break;
}
}
}
return(wr);
}
private void QueueRequest(HttpWorkerRequest wr, bool isLocal)
{
lock (this) {
if (isLocal)
{
_localQueue.Enqueue(wr);
}
else
{
_externQueue.Enqueue(wr);
}
_count++;
}
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
}
private void QueueRequest(HttpWorkerRequest wr, bool isLocal)
{
lock (this)
{
if (isLocal)
{
this._localQueue.Enqueue(wr);
}
else
{
this._externQueue.Enqueue(wr);
}
this._count++;
}
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(4, 1))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_QUEUED, wr);
}
}
private HttpWorkerRequest DequeueRequest(bool localOnly)
{
HttpWorkerRequest workerRequest = null;
while (this._count > 0)
{
lock (this)
{
if (this._localQueue.Count > 0)
{
workerRequest = (HttpWorkerRequest)this._localQueue.Dequeue();
this._count--;
}
else if (!localOnly && (this._externQueue.Count > 0))
{
workerRequest = (HttpWorkerRequest)this._externQueue.Dequeue();
this._count--;
}
}
if (workerRequest == null)
{
return(workerRequest);
}
PerfCounters.DecrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.DecrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(4, 1))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_DEQUEUED, workerRequest);
}
if (this.CheckClientConnected(workerRequest))
{
return(workerRequest);
}
HttpRuntime.RejectRequestNow(workerRequest, true);
workerRequest = null;
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_DISCONNECTED);
PerfCounters.IncrementCounter(AppPerfCounter.APP_REQUEST_DISCONNECTED);
}
return(workerRequest);
}
private void QueueRequest(HttpWorkerRequest wr, bool isLocal)
{
lock (this) {
if (isLocal)
{
_localQueue.Enqueue(wr);
}
else
{
_externQueue.Enqueue(wr);
}
_count++;
}
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_QUEUED, wr);
}
}
public void IncrementCounter(AppPerfCounter counter)
{
PerfCounters.IncrementCounter(counter);
}
/// <include file='doc\HttpDebugHandler.uex' path='docs/doc[@for="HttpDebugHandler.ProcessRequest"]/*' />
/// <devdoc>
/// <para>Drives web processing execution.</para>
/// </devdoc>
public void ProcessRequest(HttpContext context)
{
// Debugging must be enabled
try {
HttpDebugHandlerTimeLog.PrintTickDelta("Entered HttpDebugHandler");
if (!HttpRuntime.DebuggingEnabled)
{
context.Response.Write(HttpRuntime.FormatResourceString(SR.Debugging_forbidden, context.Request.Path));
context.Response.StatusCode = 403;
return;
}
// Check to see if it's a valid debug command.
string command = context.Request.Headers["Command"];
if (command == null)
{
Debug.Trace("AutoAttach", "No debug command!!");
context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_Request));
context.Response.StatusCode = 500;
return;
}
Debug.Trace("AutoAttach", "Debug command: " + command);
if (string.Compare(command, "stop-debug", true, CultureInfo.InvariantCulture) == 0)
{
context.Response.Write("OK");
return;
}
if (string.Compare(command, "start-debug", true, CultureInfo.InvariantCulture) != 0)
{
context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_Request));
context.Response.StatusCode = 500;
return;
}
// Request must be NTLM authenticated
string authType = context.WorkerRequest.GetServerVariable("AUTH_TYPE"); // go the metal
string logonUser = context.WorkerRequest.GetServerVariable("LOGON_USER");
Debug.Trace("AutoAttach", "Authentication type string: " + ((authType != null) ? authType : "NULL"));
Debug.Trace("AutoAttach", "Logon user string: " + ((logonUser != null) ? logonUser : "******"));
if (logonUser == null || logonUser.Length == 0 || authType == null || authType.Length == 0 || String.Compare(authType, "basic", true, CultureInfo.InvariantCulture) == 0)
{
Debug.Trace("AutoAttach", "Invalid logon_user or auth_type string.");
context.Response.Write(HttpRuntime.FormatResourceString(SR.Debug_Access_Denied, context.Request.Path));
context.Response.StatusCode = 401;
return;
}
// Get the session ID
String sessId = context.Request.Form["DebugSessionID"];
Debug.Trace("AutoAttach", "DebugSessionID: " + ((sessId != null) ? sessId : "NULL"));
if (sessId == null || sessId.Length == 0)
{
context.Response.Write(HttpRuntime.FormatResourceString(SR.Invalid_Debug_ID));
context.Response.StatusCode = 500;
return;
}
string s = sessId.Replace(';', '&');
HttpValueCollection valCol = new HttpValueCollection(s, true, true, Encoding.UTF8);
string clsId = (string)valCol["autoattachclsid"];
// Verify clsId
bool isClsIdOk = false;
if (clsId != null)
{
for (int i = 0; i < validClsIds.Length; i++)
{
if (clsId.ToLower(System.Globalization.CultureInfo.InvariantCulture) == validClsIds[i])
{
isClsIdOk = true;
break;
}
}
}
if (isClsIdOk == false)
{
context.Response.Write(HttpRuntime.FormatResourceString(SR.Debug_Access_Denied, context.Request.Path));
context.Response.StatusCode = 401;
Debug.Trace("AutoAttach", "Debug attach not attempted because of invalid CLSID.");
return;
}
// Attach the debugger
HttpDebugHandlerTimeLog.PrintTickDelta("About to call into MDM");
int rc = UnsafeNativeMethods.AttachDebugger(clsId, sessId, context.WorkerRequest.GetUserToken());
HttpDebugHandlerTimeLog.PrintTickDelta("Returned from call to MDM");
// If it's not S_OK, then we got a problem
if (rc != 0)
{
Debug.Trace("AutoAttach", "Debug attach failed! Return code: " + rc);
context.Response.Write(HttpRuntime.FormatResourceString(SR.Error_Attaching_with_MDM, "0x" + rc.ToString("X8")));
context.Response.StatusCode = 500;
return;
}
Debug.Trace("AutoAttach", "Debug attach successful!");
// Everything ok -- increment counter, return something (not 204)
PerfCounters.IncrementCounter(AppPerfCounter.DEBUGGING_REQUESTS);
context.Response.Write("OK");
// Set global flag for us
HttpRuntime.VSDebugAttach = true;
}
finally {
Debug.Trace("AutoAttach", "Http Debug attach done!");
HttpDebugHandlerTimeLog.PrintTickDelta("Leaving HttpDebugHandler");
HttpDebugHandlerTimeLog.Close();
}
}
public void ProcessRequest(HttpContext context)
{
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_NOT_FOUND);
throw new HttpException(0x194, System.Web.SR.GetString("Path_not_found", new object[] { context.Request.Path }));
}
public void ProcessRequest(HttpContext context)
{
if (!HttpRuntime.DebuggingEnabled)
{
context.Response.Write(System.Web.SR.GetString("Debugging_forbidden", new object[] { context.Request.Path }));
context.Response.StatusCode = 0x193;
}
else
{
string str = context.Request.Headers["Command"];
if (str == null)
{
context.Response.Write(System.Web.SR.GetString("Invalid_Debug_Request"));
context.Response.StatusCode = 500;
}
else if (StringUtil.EqualsIgnoreCase(str, "stop-debug"))
{
context.Response.Write("OK");
}
else if (!StringUtil.EqualsIgnoreCase(str, "start-debug"))
{
context.Response.Write(System.Web.SR.GetString("Invalid_Debug_Request"));
context.Response.StatusCode = 500;
}
else
{
string serverVariable = context.WorkerRequest.GetServerVariable("AUTH_TYPE");
if ((string.IsNullOrEmpty(context.WorkerRequest.GetServerVariable("LOGON_USER")) || string.IsNullOrEmpty(serverVariable)) || StringUtil.EqualsIgnoreCase(serverVariable, "basic"))
{
context.Response.Write(System.Web.SR.GetString("Debug_Access_Denied", new object[] { context.Request.Path }));
context.Response.StatusCode = 0x191;
}
else
{
string str4 = context.Request.Form["DebugSessionID"];
if (string.IsNullOrEmpty(str4))
{
context.Response.Write(System.Web.SR.GetString("Invalid_Debug_ID"));
context.Response.StatusCode = 500;
}
else
{
HttpValueCollection values = new HttpValueCollection(str4.Replace(';', '&'), true, true, Encoding.UTF8);
string str6 = values["autoattachclsid"];
bool flag = false;
if (str6 != null)
{
for (int i = 0; i < validClsIds.Length; i++)
{
if (StringUtil.EqualsIgnoreCase(str6, validClsIds[i]))
{
flag = true;
break;
}
}
}
if (!flag)
{
context.Response.Write(System.Web.SR.GetString("Debug_Access_Denied", new object[] { context.Request.Path }));
context.Response.StatusCode = 0x191;
}
else
{
int num2 = UnsafeNativeMethods.AttachDebugger(str6, str4, context.WorkerRequest.GetUserToken());
if (num2 != 0)
{
context.Response.Write(System.Web.SR.GetString("Error_Attaching_with_MDM", new object[] { "0x" + num2.ToString("X8", CultureInfo.InvariantCulture) }));
context.Response.StatusCode = 500;
}
else
{
PerfCounters.IncrementCounter(AppPerfCounter.DEBUGGING_REQUESTS);
context.Response.Write("OK");
}
}
}
}
}
}
}
private async Task <AspNetWebSocket> ProcessRequestImplAsync()
{
AspNetWebSocket webSocket = null;
try {
// SendResponse and other asynchronous notifications cannot be process by ASP.NET after this point.
_root.WorkerRequest.SuppressSendResponseNotifications();
// A flush is necessary to activate the WebSocket module so that we can get its pointer.
//
// DevDiv #401948: We can't allow a flush failure to propagate out, otherwise the rest of
// this method doesn't run, which could leak resources (by not invoking the user callback)
// or cause weird behavior (by not calling CompleteTransitionToWebSocket, which could corrupt
// server state). If the flush fails, we'll wait to propagate the exception until a safe
// point later in this method.
ExceptionDispatchInfo flushExceptionDispatchInfo = DoFlush();
// Create the AspNetWebSocket. There's a chance that the client disconnected before we
// hit this code. If this is the case, we'll pass a null WebSocketPipe to the
// AspNetWebSocket ctor, which immediately sets the socket into an aborted state.
UnmanagedWebSocketContext unmanagedWebSocketContext = _root.WorkerRequest.GetWebSocketContext();
WebSocketPipe pipe = (unmanagedWebSocketContext != null) ? new WebSocketPipe(unmanagedWebSocketContext, PerfCounters.Instance) : null;
webSocket = new AspNetWebSocket(pipe, _subProtocol);
// slim down the HttpContext as much as possible to allow the GC to reclaim memory
_httpContext.CompleteTransitionToWebSocket();
// always install a new SynchronizationContext, even if the user is running in legacy SynchronizationContext mode
AspNetSynchronizationContext syncContext = new AspNetSynchronizationContext(this);
_httpContext.SyncContext = syncContext;
bool webSocketRequestSucceeded = false;
try {
// need to keep track of this in the manager so that we can abort if it the AppDomain goes down
AspNetWebSocketManager.Current.Add(webSocket);
// bump up the total count (the currently-executing count is recorded separately)
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_TOTAL_WEBSOCKETS);
// Release the reference to the user delegate (which might just be a simple initialization routine) so that
// the GC can claim it. The only thing that needs to remain alive is the Task itself, which we're referencing.
Task task = null;
syncContext.Send(_ => {
task = _userFunc(new AspNetWebSocketContextImpl(new HttpContextWrapper(_httpContext), _root.WorkerRequest, webSocket));
}, null);
// Was there an exception from user code? If so, rethrow (which logs).
ExceptionDispatchInfo exception = syncContext.ExceptionDispatchInfo;
if (exception != null)
{
exception.Throw();
}
_userFunc = null;
await task.ConfigureAwait(continueOnCapturedContext : false);
// Was there an exception from the earlier call to DoFlush? If so, rethrow (which logs).
// This needs to occur after the user's callback finishes, otherwise ASP.NET could try
// to complete the request while the callback is still accessing it.
if (flushExceptionDispatchInfo != null)
{
flushExceptionDispatchInfo.Throw();
}
// Any final state except Aborted is marked as 'success'.
// It's possible execution never reaches this point, e.g. if the user's
// callback throws an exception. In that case, 'webSocketRequestSucceeded'
// will keep its default value of false, and the performance counter
// will mark this request as having failed.
if (webSocket.State != WebSocketState.Aborted)
{
webSocketRequestSucceeded = true;
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_SUCCEEDED_WEBSOCKETS);
}
}
finally {
// we need to make sure the user can't call the WebSocket any more after this point
_isProcessingComplete = true;
webSocket.DisposeInternal();
AspNetWebSocketManager.Current.Remove(webSocket);
if (!webSocketRequestSucceeded)
{
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_FAILED_WEBSOCKETS);
}
}
}
catch (Exception ex) {
// don't let the exception propagate upward; just log it instead
WebBaseEvent.RaiseRuntimeError(ex, null);
}
return(webSocket);
}