Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Net/net/Logging.cs

@@ -0,0 +1,187 @@
+//------------------------------------------------------------------------------
+// <copyright file="Logging.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+namespace System.Net
+{
+    using System.Collections;
+    using System.IO;
+    using System.Threading;
+    using System.Diagnostics;
+    using System.Security.Permissions;
+    using System.Runtime.InteropServices;
+    using System.Globalization;
+    using Microsoft.Win32;
+    using System.Text;
+    internal static class Logging
+    {
+        private static P2PTraceSource s_P2PTraceSource;
+        // <SecurityKernel Critical="True" Ring="0">
+        // <SatisfiesLinkDemand Name="AppDomain.add_ProcessExit(System.EventHandler):System.Void" />
+        // <SatisfiesLinkDemand Name="AppDomain.add_DomainUnload(System.EventHandler):System.Void" />
+        // <ReferencesCritical Name="Method: ProcessExitEventHandler(Object, EventArgs):Void" Ring="2" />
+        // <ReferencesCritical Name="Method: DomainUnloadEventHandler(Object, EventArgs):Void" Ring="2" />
+        // </SecurityKernel>
+        [System.Security.SecurityCritical]
+        static Logging()
+        {
+            s_P2PTraceSource = new P2PTraceSource();
+            if (s_P2PTraceSource.Switch.ShouldTrace(TraceEventType.Critical))
+            {
+                AppDomain currentDomain = AppDomain.CurrentDomain;
+                currentDomain.ProcessExit += new EventHandler(ProcessExitEventHandler);
+                //currentDomain.UnhandledException += new UnhandledExceptionEventHandler(UnhandledExceptionEventHandler);
+                currentDomain.DomainUnload += new EventHandler(DomainUnloadEventHandler);
+            }
+        }
+        // <SecurityKernel Critical="True" Ring="1">
+        // <ReferencesCritical Name="Method: Close():Void" Ring="1" />
+        // </SecurityKernel>
+        [System.Security.SecurityCritical]
+        private static void DomainUnloadEventHandler(object sender, EventArgs e)
+        {
+            Close();
+        }
+
+        /*
+        private static void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e)
+        {
+            s_P2PTraceSource.TraceEvent(TraceEventType.Critical, UNHANDLED_EXCEPTION_EVENT_ID, "Unhandled Exception {0}", e.ExceptionObject);
+        }
+        */
+        // <SecurityKernel Critical="True" Ring="1">
+        // <ReferencesCritical Name="Method: Close():Void" Ring="1" />
+        // </SecurityKernel>
+        [System.Security.SecurityCritical]
+        private static void ProcessExitEventHandler(object sender, EventArgs e)
+        {
+            Close();
+        }
+        // <SecurityKernel Critical="True" Ring="0">
+        // <SatisfiesLinkDemand Name="TraceSource.Close():System.Void" />
+        // </SecurityKernel>
+        [System.Security.SecurityCritical]
+        private static void Close()
+        {
+            s_P2PTraceSource.Close();
+        }
+        //private Logging() {}
+        internal static P2PTraceSource P2PTraceSource
+        {
+            get
+            {
+                return s_P2PTraceSource;
+            }
+        }
+
+        internal static void Enter(TraceSource source, string method)
+        {
+            if(source.Switch.ShouldTrace(TraceEventType.Verbose))
+            {
+                source.TraceEvent(TraceEventType.Verbose, 0, "Entering --> " + method);
+            }
+        }
+        internal static void Leave(TraceSource source, string message)
+        {
+            if (source.Switch.ShouldTrace(TraceEventType.Verbose))
+            {
+                source.TraceEvent(TraceEventType.Verbose, 0, "Leaving <-- " + message);
+            }
+        }
+
+        /*
+        internal static void Enter(TraceSource source, string type, object obj, string method)
+        {
+
+        }
+        internal static void Enter(TraceSource source, string type, object obj, string method, params object[] args)
+        {
+
+        }
+         * */
+
+        internal static void DumpData(TraceSource source, TraceEventType eventType, int maxDataSize, byte[] buffer, int offset, int length)
+        {
+            if (buffer == null ||
+                    buffer.Length == 0 ||
+                    offset > buffer.Length)
+            {
+                return;
+            }
+            if (length > maxDataSize)
+            {
+                source.TraceEvent(eventType, 0, "dumping {0} of {1} bytes", maxDataSize, length);
+                length = maxDataSize;
+            }
+            if ((length < 0) || (length > buffer.Length - offset))
+            {
+                length = buffer.Length - offset;
+            }
+            do
+            {
+                int n = Math.Min(length, 16);
+                StringBuilder sb = new StringBuilder();
+                sb.Append(String.Format(CultureInfo.CurrentCulture, "{0:X8} : ", offset));
+                for (int i = 0; i < n; ++i)
+                {
+                    sb.Append(String.Format(CultureInfo.CurrentCulture, "{0:X2}", buffer[offset + i]) + ((i == 7) ? '-' : ' '));
+                }
+                for (int i = n; i < 16; ++i)
+                {
+                    sb.Append("   ");
+                }
+                sb.Append(": ");
+                for (int i = 0; i < n; ++i)
+                {
+                    sb.Append(((buffer[offset + i] < 0x20) || (buffer[offset + i] > 0x7e))
+                                ? '.'
+                                : (char)(buffer[offset + i]));
+                }
+                source.TraceEvent(eventType, 0, sb.ToString());
+                offset += n;
+                length -= n;
+            } while (length > 0);
+
+        }
+
+    }
+
+    internal class P2PTraceSource : TraceSource
+    {
+        private const string P2PTraceSourceName = "System.Net.PeerToPeer";
+        private const int DefaultMaxDataSize = 1024;
+        private const string AttributeNameMaxDataSize = "maxdatasize";
+        private static readonly string[] P2PTraceSourceSupportedAttributes = new string[] { AttributeNameMaxDataSize };
+        private readonly int m_maxDataSize = DefaultMaxDataSize;
+
+        internal P2PTraceSource() :base(P2PTraceSourceName)
+        {
+            if (Attributes.ContainsKey(AttributeNameMaxDataSize))
+            {
+                try{
+                    m_maxDataSize = Int32.Parse(Attributes[AttributeNameMaxDataSize], NumberFormatInfo.InvariantInfo);
+                }
+                catch (Exception exception) {
+                    if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) {
+                        throw;
+                    }
+                }
+            }
+        }
+        protected  override string[] GetSupportedAttributes()
+        {
+            return P2PTraceSourceSupportedAttributes;
+        }
+
+        internal int MaxDataSize
+        {
+            get
+            {
+                return m_maxDataSize;
+            }
+        }
+    }
+ 
+
+}