|
//------------------------------------------------------------------------------
// <copyright file="Logging.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Net.PeerToPeer
{
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Threading;
using System.Runtime.Serialization;
using System.Security.Permissions;
/// <remarks>
/// The PeerToPeerException class encpasulates the exceptions for
/// PeerToPeer classes.
/// NOTE:
/// This class is marked serializable but does not implement
/// ISerializable interface. There are no private/public properties
/// we keep track across the serialization. The base class message
/// and inner exceptions are used.
/// </remarks>
[Serializable]
public class PeerToPeerException : Exception, ISerializable
{
private const UInt32 FACILITY_P2P = 99;
public PeerToPeerException() { }
/// <summary>
/// Construtor
/// </summary>
/// <param name="message"></param>
public PeerToPeerException(string message) : base(message) { }
/// <summary>
/// Constructor
/// </summary>
/// <param name="message"></param>
/// <param name="innerException"></param>
public PeerToPeerException(string message, Exception innerException) : base(message, innerException) { }
/// <summary>
/// HRESULT Structure
/// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
/// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
/// +---+-+-+-----------------------+-------------------------------+
/// |Sev|C|R| Facility | Code |
/// +---+-+-+-----------------------+-------------------------------+
///
/// The intent here is that when we get a HRESULT from a P2P.dll,
/// we need to get the message from the P2p.dll resource table.
/// If the HRESULT is something like E_INVALIDARG, we need to get the
/// message from the SYSTEM table.
/// Apart from the native exception message, we would like to provide
/// a friendly message to explain the context under which the exception
/// occurred from managed code developers.
/// So we first try to get the message from the P2P.dll if the HRESULT
/// comes with a facility ID for P2P. Otherwise we get the exception message from
/// system. We then construct a Win32Exception and set this as an inner exception
///
/// If in case we can't get the message from either system or P2p, then
/// we try the Marshal class and throw a exception from the HRESULT
///
/// If all else fails we simply throw an exception with no inner
/// exception but still give the HRESULT
///
/// A note that we are getting the handle for P2p.dll from the LoadLibrary
/// we originally did for checking if P2P.dll is present on the system.
/// Since we are getting the underlying handle, there is a possibility that
/// the Library is freed [AppDomain shutdown] and we are trying to
/// use the handle. The code is in a try catch block here so that
/// we catch these situations and still recover.
/// </summary>
/// <param name="message">The error message that we would like to set as the message for the exception</param>///
/// <param name="hr">The error code</param>
/// <returns>a PeerToPeerException</returns>
// <SecurityKernel Critical="True" Ring="0">
// <CallsSuppressUnmanagedCode Name="UnsafeSystemNativeMethods.FormatMessage(System.Net.FormatMessageFlags,System.IntPtr,System.UInt32,System.UInt32,System.IntPtr&,System.UInt32,System.IntPtr):System.UInt32" />
// <CallsSuppressUnmanagedCode Name="UnsafeSystemNativeMethods.LocalFree(System.IntPtr):System.UInt32" />
// <SatisfiesLinkDemand Name="Marshal.PtrToStringUni(System.IntPtr):System.String" />
// <SatisfiesLinkDemand Name="Win32Exception..ctor(System.Int32,System.String)" />
// <SatisfiesLinkDemand Name="Marshal.GetExceptionForHR(System.Int32):System.Exception" />
// <ReferencesCritical Name="Method: PeerToPeerOSHelper.get_P2PModuleHandle():System.IntPtr" Ring="1" />
// </SecurityKernel>
[System.Security.SecurityCritical]
internal static PeerToPeerException CreateFromHr(string message, Int32 hr)
{
PeerToPeerException p2pEx = null;
int facility = ((hr >> 16) & 0x1FFF);
IntPtr NativeMessagePtr = IntPtr.Zero;
try
{
UInt32 dwLength = UnsafeSystemNativeMethods.FormatMessage(
FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER |
FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY |
(facility == FACILITY_P2P ? FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE : FormatMessageFlags.FORMAT_MESSAGE_FROM_SYSTEM),
(facility == FACILITY_P2P ? PeerToPeerOSHelper.P2PModuleHandle : IntPtr.Zero),
(uint)(hr),
0,
ref NativeMessagePtr,
0,
IntPtr.Zero);
if (dwLength != 0)
{
string NativeMessage = Marshal.PtrToStringUni(NativeMessagePtr);
p2pEx = new PeerToPeerException(message, new Win32Exception(hr, NativeMessage));
}
else
{
p2pEx = new PeerToPeerException(message, Marshal.GetExceptionForHR(hr));
}
}
catch(Exception ex)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Warning, 0, "Could not get the error message for error code {0} - Exception {1}", hr, ex);
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
}
finally
{
if (NativeMessagePtr != IntPtr.Zero)
{
UnsafeSystemNativeMethods.LocalFree(NativeMessagePtr);
}
}
if (p2pEx == null)
{
Logging.P2PTraceSource.TraceEvent(TraceEventType.Warning, 0, "Could not get the error message for error code {0}", hr);
p2pEx = new PeerToPeerException(message + "Underlying native error " + hr);
}
Logging.P2PTraceSource.TraceEvent(TraceEventType.Error, 0, "Exception: {0}", p2pEx);
return p2pEx;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
protected PeerToPeerException(SerializationInfo info, StreamingContext context) : base (info, context) {}
// <SecurityKernel Critical="True" Ring="0">
// <SatisfiesLinkDemand Name="Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext):System.Void" />
// </SecurityKernel>
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.Net.dll is still using pre-v4 security model and needs this demand")]
[System.Security.SecurityCritical]
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.SerializationFormatter)]
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context) {
GetObjectData(info, context);
}
// <SecurityKernel Critical="True" Ring="0">
// <SatisfiesLinkDemand Name="Exception.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext):System.Void" />
// </SecurityKernel>
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.Net.dll is still using pre-v4 security model and needs this demand")]
[System.Security.SecurityCritical]
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.SerializationFormatter)]
public override void GetObjectData(SerializationInfo info, StreamingContext context)
{
base.GetObjectData(info, context);
}
}
}
|