Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/HttpDebugHandler.cs

@@ -0,0 +1,275 @@
+//------------------------------------------------------------------------------
+// <copyright file="HttpDebugHandler.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ * Handler for DEBUG verb
+ * 
+ * Copyright (c) 2000 Microsoft Corporation
+ */
+
+namespace System.Web {
+
+    using System.Configuration;
+    using System.Globalization;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using System.Text;
+    using System.Web.Configuration;
+    using System.Web.Hosting;
+    using System.Web.Util;
+/*
+This is just a temporary code to get some timings for the Http Debug request.  To enable it, add the following
+to the app's "web.config" file:
+
+<configuration>
+
+        <configSections>
+            <section name="httpDebug" type="System.Configuration.DictionarySectionHandler,System" />
+        </configSections>
+
+        <httpDebug>
+           <add key="enable" value="1" />
+           <add key="path" value="c:\dir\file.log" />
+        </httpDebug>
+
+</configuration>
+
+*/
+    using System.Collections;
+
+#if PERF
+
+    internal class HttpDebugHandlerTimeLog {
+        private static int initialTick = 0;
+        private static int isEnabled = -1;
+        private static StreamWriter writer = null;
+        private static FileStream fstream = null;
+
+        private HttpDebugHandlerTimeLog() {
+        }
+
+        private static bool IsEnabled {
+            get {
+                if (isEnabled == -1) {
+                    // Else check to see if config settings enables it
+                    Hashtable h = (Hashtable) WebConfigurationManager.GetWebApplicationSection("httpDebug");
+                    if (h != null) {
+                        string s = (string) h["enable"];
+                        if ((s != null) && (s == "1")) {
+                            // Open file handle if needed
+                            try {
+                                string filename = (string) h["path"];
+                                if (filename != null) {
+                                    fstream = new FileStream(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
+                                    writer = new StreamWriter(fstream);
+                                    isEnabled = 1;
+                                }
+                            }
+                            catch {
+                                isEnabled = 0;
+                                Close();
+                            }
+                        }
+                    }
+                    
+                    // If still undecided here, then it's off
+                    if (isEnabled == -1) {
+                        isEnabled = 0;
+                    }
+                }
+
+                return (isEnabled == 1) ? true : false;
+            }
+        }
+
+        internal static void Close() {
+            if (writer != null) {
+                writer.Flush();
+                writer.Close();
+                writer = null;
+            }
+            if (fstream != null) {
+                fstream.Close();
+                fstream = null;
+            }
+        }
+        
+        internal static void PrintTickDelta(string s) {
+            if (! IsEnabled) {
+                return;
+            }
+            if (initialTick == 0) {
+                initialTick = Environment.TickCount;
+                SafeNativeMethods.OutputDebugString(s + " : " + initialTick + " (HttpDebugHandler + 0)\n");
+                if (writer != null) {
+                    writer.WriteLine(s + " : " + initialTick + " (HttpDebugHandler + 0)");
+                }
+            }
+            else {
+                int curTick = Environment.TickCount;
+                SafeNativeMethods.OutputDebugString(s + " : " + curTick + " (HttpDebugHandler + " + (curTick - initialTick) + ")\n");
+                if (writer != null) {
+                    writer.WriteLine(s + " : " + curTick + " (HttpDebugHandler + " + (curTick - initialTick) + ")");
+                }
+            }
+        }
+    }
+
+#endif
+
+    /// <devdoc>
+    ///    <para>Handler for debugging operations.</para>
+    /// </devdoc>
+    internal class HttpDebugHandler : IHttpHandler {
+
+        private static string[] validClsIds = {"{70f65411-fe8c-4248-bcff-701c8b2f4529}",
+                                               "{62a78ac2-7d9a-4377-b97e-6965919fdd02}",
+                                               "{cc23651f-4574-438f-b4aa-bcb28b6b3ecf}",
+                                               "{dbfdb1d0-04a4-4315-b15c-f874f6b6e90b}",
+                                               "{a4fcb474-2687-4924-b0ad-7caf331db826}",
+                                               "{beb261f6-d5f0-43ba-baf4-8b79785fffaf}",
+                                               "{8e2f5e28-d4e2-44c0-aa02-f8c5beb70cac}",
+                                               "{08100915-0f41-4ccf-9564-ebaa5d49446c}"};
+
+        internal HttpDebugHandler () {
+        }
+        
+
+        /// <devdoc>
+        ///    <para>Drives web processing execution.</para>
+        /// </devdoc>
+        public void ProcessRequest(HttpContext context) {
+            // Debugging must be enabled
+
+            try {
+#if PERF
+                HttpDebugHandlerTimeLog.PrintTickDelta("Entered HttpDebugHandler");
+#endif
+
+                if (!HttpRuntime.DebuggingEnabled) {
+                    context.Response.Write(SR.GetString(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(SR.GetString(SR.Invalid_Debug_Request));
+                    context.Response.StatusCode = 500;
+                    return;
+                }
+
+                Debug.Trace("AutoAttach", "Debug command: " + command);
+
+                if (StringUtil.EqualsIgnoreCase(command, "stop-debug")) {
+                    context.Response.Write("OK");
+                    return;
+                }
+
+                if (!StringUtil.EqualsIgnoreCase(command, "start-debug")) {
+                    context.Response.Write(SR.GetString(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 : "NULL"));
+
+                if (String.IsNullOrEmpty(logonUser) || String.IsNullOrEmpty(authType) || StringUtil.EqualsIgnoreCase(authType, "basic")) 
+                {
+                    Debug.Trace("AutoAttach", "Invalid logon_user or auth_type string.");
+                    context.Response.Write(SR.GetString(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 (String.IsNullOrEmpty(sessId)) {
+                    context.Response.Write(SR.GetString(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 (StringUtil.EqualsIgnoreCase(clsId, validClsIds[i])) {
+                            isClsIdOk = true;
+                            break;
+                        }
+                    }
+                }
+                if (isClsIdOk == false) {
+                    context.Response.Write(SR.GetString(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
+#if PERF
+                HttpDebugHandlerTimeLog.PrintTickDelta("About to call into MDM");
+#endif
+
+                int rc = UnsafeNativeMethods.AttachDebugger(clsId, sessId, context.WorkerRequest.GetUserToken());
+
+#if PERF
+                HttpDebugHandlerTimeLog.PrintTickDelta("Returned from call to MDM");
+#endif
+
+                // 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(SR.GetString(SR.Error_Attaching_with_MDM, "0x" + rc.ToString("X8", CultureInfo.InvariantCulture)));
+                    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");
+            }
+            finally {
+                Debug.Trace("AutoAttach","Http Debug attach done!");
+
+#if PERF
+                HttpDebugHandlerTimeLog.PrintTickDelta("Leaving HttpDebugHandler");
+                HttpDebugHandlerTimeLog.Close();
+#endif
+            }
+        }
+
+
+        /// <devdoc>
+        ///    <para>Indicates whether an HttpDebugHandler instance can be recycled and used for 
+        ///       another request.</para>
+        /// </devdoc>
+        public bool IsReusable {
+            get { return true; }
+        }
+    }
+
+}
+