|
//------------------------------------------------------------------------------
// <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;
}
}
}
}
|