//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------

namespace System.ServiceModel.Diagnostics
{
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.IO;
    using System.Runtime;
    using System.Runtime.Diagnostics;
    using System.Security;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Configuration;
    using System.ServiceModel.Diagnostics.Application;
    using System.ServiceModel.Dispatcher;
    using System.Xml;

    [Flags]
    internal enum MessageLoggingSource : int
    {
        None = 0,
        TransportReceive = 2,
        TransportSend = 4,
        Transport = TransportReceive | TransportSend,
        ServiceLevelReceiveDatagram = 16,
        ServiceLevelSendDatagram = 32,
        ServiceLevelReceiveRequest = 64,
        ServiceLevelSendRequest = 128,
        ServiceLevelReceiveReply = 256,
        ServiceLevelSendReply = 512,
        ServiceLevelReceive = ServiceLevelReceiveReply | ServiceLevelReceiveRequest | ServiceLevelReceiveDatagram,
        ServiceLevelSend = ServiceLevelSendReply | ServiceLevelSendRequest | ServiceLevelSendDatagram,
        ServiceLevelService = ServiceLevelSendReply | ServiceLevelReceiveRequest | ServiceLevelReceiveDatagram,
        ServiceLevelProxy = ServiceLevelReceiveReply | ServiceLevelSendRequest | ServiceLevelSendDatagram,
        ServiceLevel = ServiceLevelReceive | ServiceLevelSend,
        Malformed = 1024,
        LastChance = 2048,
        All = int.MaxValue
    }

    internal static class MessageLogger
    {
        const string MessageTraceSourceName = "System.ServiceModel.MessageLogging";
        const string DefaultTraceListenerName = "Default";
        const int Unlimited = -1;

        static MessageLoggingSource sources = default(MessageLoggingSource);
        static bool logKnownPii;
        static bool logMessageBody = false;
        static int maxMessagesToLog;
        static int numberOfMessagesToLog;
        static int maxMessageSize;
        static PiiTraceSource messageTraceSource;
        static bool attemptedTraceSourceInitialization = false;
        static bool initialized = false;
        static bool initializing = false;
        static bool inPartialTrust = false;
        static object syncObject = new object();
        static object filterLock = new object();
        static List<XPathMessageFilter> messageFilterTable;
        static bool lastWriteSucceeded = true;
        static string[][] piiBodyPaths;
        static string[][] piiHeadersPaths;
        static string[] securityActions;

        static int FilterCount
        {
            get { return MessageLogger.Filters.Count; }
        }

        static bool FilterMessages
        {
            get { return MessageLogger.FilterCount > 0 && (MessageLogger.numberOfMessagesToLog > 0 || MessageLogger.numberOfMessagesToLog == MessageLogger.Unlimited); }
        }

        internal static bool LogKnownPii
        {
            get 
            {
                Fx.Assert(MessageLogger.initialized, "MessageLogger should be initialized before trying to retrieve LogKnownPii");
                return MessageLogger.logKnownPii; 
            }
            set
            {
                MessageLogger.logKnownPii = value;
            }
        }

        internal static bool LogMalformedMessages
        {
            get { return (MessageLogger.Sources & MessageLoggingSource.Malformed) != 0; }
            set
            {
                lock (MessageLogger.syncObject)
                {
                    bool shouldProcessAudit = ShouldProcessAudit(MessageLoggingSource.Malformed, value);
                    if (value)
                    {
                        EnsureMessageTraceSource();
                        if (!MessageLogger.inPartialTrust)
                        {
                            MessageLogger.sources |= MessageLoggingSource.Malformed;
                        }
                    }
                    else
                    {
                        MessageLogger.sources &= MessageLoggingSource.All & ~MessageLoggingSource.Malformed;
                    }
                    if (shouldProcessAudit)
                    {
                        ProcessAudit(value);
                    }
                }
            }
        }

        internal static bool LogMessagesAtServiceLevel
        {
            get { return (MessageLogger.Sources & MessageLoggingSource.ServiceLevel) != 0; }
            set
            {
                lock (MessageLogger.syncObject)
                {
                    bool shouldProcessAudit = ShouldProcessAudit(MessageLoggingSource.ServiceLevel, value);
                    if (value)
                    {
                        EnsureMessageTraceSource();
                        if (!MessageLogger.inPartialTrust)
                        {
                            MessageLogger.sources |= MessageLoggingSource.ServiceLevel;
                        }
                    }
                    else
                    {
                        MessageLogger.sources &= MessageLoggingSource.All & ~MessageLoggingSource.ServiceLevel;
                    }
                    if (shouldProcessAudit)
                    {
                        ProcessAudit(value);
                    }
                }
            }
        }

        internal static bool LogMessagesAtTransportLevel
        {
            get { return (MessageLogger.Sources & MessageLoggingSource.Transport) != 0; }
            set
            {
                lock (MessageLogger.syncObject)
                {
                    bool shouldProcessAudit = ShouldProcessAudit(MessageLoggingSource.Transport, value);
                    if (value)
                    {
                        EnsureMessageTraceSource();
                        if (!MessageLogger.inPartialTrust)
                        {
                            MessageLogger.sources |= MessageLoggingSource.Transport;
                        }
                    }
                    else
                    {
                        MessageLogger.sources &= MessageLoggingSource.All & ~MessageLoggingSource.Transport;
                    }
                    if (shouldProcessAudit)
                    {
                        ProcessAudit(value);
                    }
                }
            }
        }

        internal static bool LogMessageBody
        {
            get
            {
                Fx.Assert(MessageLogger.initialized, "");
                return logMessageBody;
            }
            set { logMessageBody = value; }
        }

        internal static bool LoggingEnabled
        {
            get { return MessageLogger.Sources != default(MessageLoggingSource); }
        }

        internal static int MaxMessageSize
        {
            get
            {
                Fx.Assert(MessageLogger.initialized, "");
                return maxMessageSize;
            }
            set { maxMessageSize = value; }
        }

        internal static int MaxNumberOfMessagesToLog
        {
            get
            {
                Fx.Assert(MessageLogger.initialized, "");
                return maxMessagesToLog;
            }
            set
            {
                //resetting the max resets the actual counter
                lock (MessageLogger.syncObject)
                {
                    maxMessagesToLog = value;
                    MessageLogger.numberOfMessagesToLog = maxMessagesToLog;
                }
            }
        }

        static List<XPathMessageFilter> Filters
        {
            get
            {
                if (MessageLogger.messageFilterTable == null)
                {
                    lock (MessageLogger.filterLock)
                    {
                        if (MessageLogger.messageFilterTable == null)
                        {
                            List<XPathMessageFilter> temp = new List<XPathMessageFilter>();
                            MessageLogger.messageFilterTable = temp;
                        }
                    }
                }

                return MessageLogger.messageFilterTable;
            }
        }

        static MessageLoggingSource Sources
        {
            get
            {
                if (!MessageLogger.initialized)
                {
                    MessageLogger.EnsureInitialized();
                }
                return MessageLogger.sources;
            }
        }

        static bool AddFilter(XPathMessageFilter filter)
        {
            if (filter == null)
            {
                filter = new XPathMessageFilter(""); //if there is an empty add filter tag, add a match-all filter
            }

            MessageLogger.Filters.Add(filter);
            return true;
        }

        internal static bool ShouldLogMalformed
        {
            get { return ShouldLogMessages(MessageLoggingSource.Malformed); }
        }

        static bool ShouldLogMessages(MessageLoggingSource source)
        {
            return (source & MessageLogger.Sources) != 0 &&
                   ((MessageLogger.MessageTraceSource != null) ||
                   ((source & MessageLoggingSource.Malformed) != 0 && TD.MessageLogWarningIsEnabled()) ||
                   TD.MessageLogInfoIsEnabled());
        }

        internal static void LogMessage(MessageLoggingSource source, string data)
        {
            try
            {
                if (ShouldLogMessages(MessageLoggingSource.Malformed))
                {
                    LogInternal(source, data);
                }
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e)) throw;
                FailedToLogMessage(e);
            }
        }

        internal static void LogMessage(Stream stream, MessageLoggingSource source)
        {
            try
            {
                ThrowIfNotMalformed(source);
                if (ShouldLogMessages(source))
                {
                    LogInternal(new MessageLogTraceRecord(stream, source));
                }
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e)) throw;
                FailedToLogMessage(e);
            }
        }

        internal static void LogMessage(ArraySegment<byte> buffer, MessageLoggingSource source)
        {
            try
            {
                ThrowIfNotMalformed(source);
                if (ShouldLogMessages(source))
                {
                    LogInternal(new MessageLogTraceRecord(buffer, source));
                }
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e)) throw;
                FailedToLogMessage(e);
            }
        }

        internal static void LogMessage(ref Message message, XmlReader reader, MessageLoggingSource source)
        {
            Fx.Assert(null != message, "");
            try
            {
                if (ShouldLogMessages(source))
                {
                    LogMessageImpl(ref message, reader, source);
                }
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e)) throw;
                FailedToLogMessage(e);
            }
        }

        internal static void LogMessage(ref Message message, MessageLoggingSource source)
        {
            LogMessage(ref message, null, source);
        }

        static void LogMessageImpl(ref Message message, XmlReader reader, MessageLoggingSource source)
        {
            ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? TraceUtility.ExtractActivity(message) : null;
            using (ServiceModelActivity.BoundOperation(activity))
            {
                if (ShouldLogMessages(source) && (MessageLogger.numberOfMessagesToLog > 0 || MessageLogger.numberOfMessagesToLog == MessageLogger.Unlimited))
                {
                    bool lastChance = (source & MessageLoggingSource.LastChance) != 0 || (source & MessageLoggingSource.TransportSend) != 0;
                    source &= ~MessageLoggingSource.LastChance;
                    // MessageLogger doesn't log AddressingVersion.None in the encoder since we want to make sure we log 
                    // as much of the message as possible. So let the Transport log later.
                    if ((lastChance || message is NullMessage || message.Version.Addressing != AddressingVersion.None)
                            && MatchFilters(message, source))
                    {
                        if (MessageLogger.numberOfMessagesToLog == MessageLogger.Unlimited || MessageLogger.numberOfMessagesToLog > 0)
                        {
                            MessageLogTraceRecord record = new MessageLogTraceRecord(ref message, reader, source, MessageLogger.LogMessageBody);
                            LogInternal(record);
                        }
                    }
                }
            }
        }

        static bool HasSecurityAction(Message message)
        {
            Fx.Assert(null != message, "");

            string action = message.Headers.Action;
            bool result = false;
            if (String.IsNullOrEmpty(action))
            {
                result = true;
            }
            else
            {
                foreach (string securityAction in MessageLogger.SecurityActions)
                {
                    if (0 == String.CompareOrdinal(action, securityAction))
                    {
                        result = true;
                        break;
                    }
                }
            }

            return result;
        }

        static void LogInternal(MessageLogTraceRecord record)
        {
            Fx.Assert(null != record, "record cannot be null");

            PlainXmlWriter xmlWriter = new PlainXmlWriter(MessageLogger.MaxMessageSize);

            try
            {
                record.WriteTo(xmlWriter);
                xmlWriter.Close();
                TraceXPathNavigator navigator = xmlWriter.Navigator;
                
                if ((MessageLogger.messageTraceSource != null && 
                    !MessageLogger.messageTraceSource.ShouldLogPii) ||
                    !MessageLogger.LogKnownPii)
                {
                    navigator.RemovePii(MessageLogger.PiiHeadersPaths);
                    if (MessageLogger.LogMessageBody && null != record.Message)
                    {
                        if (HasSecurityAction(record.Message))
                        {
                            navigator.RemovePii(MessageLogger.PiiBodyPaths);
                        }
                    }
                }

                LogInternal(record.MessageLoggingSource, navigator);
            }
            catch (PlainXmlWriter.MaxSizeExceededException)
            {
                if (DiagnosticUtility.ShouldTraceWarning)
                {
                    TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.MessageNotLoggedQuotaExceeded,
                        SR.GetString(SR.TraceCodeMessageNotLoggedQuotaExceeded), record.Message);
                }
            }
        }

        static void IncrementLoggedMessagesCount(object data)
        {
            if (MessageLogger.numberOfMessagesToLog > 0)
            {
                lock (MessageLogger.syncObject)
                {
                    if (MessageLogger.numberOfMessagesToLog > 0)
                    {
                        MessageLogger.numberOfMessagesToLog--;
                        if (0 == MessageLogger.numberOfMessagesToLog)
                        {
                            if (DiagnosticUtility.ShouldTraceInformation)
                            {
                                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.MessageCountLimitExceeded,
                                    SR.GetString(SR.TraceCodeMessageCountLimitExceeded), data);
                            }
                        }
                    }
                }
            }

            lock (MessageLogger.syncObject)
            {
                if (!MessageLogger.lastWriteSucceeded)
                {
                    MessageLogger.lastWriteSucceeded = true;
                }
            }
        }

        static void FailedToLogMessage(Exception e)
        {
            //If something goes wrong, we do not want to fail the app, just log one event log entry per block of failures
            bool shouldLogError = false;
            lock (MessageLogger.syncObject)
            {
                if (MessageLogger.lastWriteSucceeded)
                {
                    MessageLogger.lastWriteSucceeded = false;
                    shouldLogError = true;
                }
            }
            if (shouldLogError)
            {
                DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error,
                    (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging,
                    (uint)System.Runtime.Diagnostics.EventLogEventId.FailedToLogMessage,
                    e.ToString());
            }
        }

        static void LogInternal(MessageLoggingSource source, object data)
        {
            if ((source & MessageLoggingSource.Malformed) != 0)
            {
                if (TD.MessageLogWarningIsEnabled() && !TD.MessageLogWarning(data.ToString()))
                {
                    if (TD.MessageLogEventSizeExceededIsEnabled())
                    {
                        TD.MessageLogEventSizeExceeded();
                    }
                }
            }
            else
            {
                if (TD.MessageLogInfoIsEnabled() && !TD.MessageLogInfo(data.ToString()))
                {
                    if (TD.MessageLogEventSizeExceededIsEnabled())
                    {
                        TD.MessageLogEventSizeExceeded();
                    }                   
                }
            }
            if (MessageLogger.MessageTraceSource != null)
            {
                MessageLogger.MessageTraceSource.TraceData(TraceEventType.Information, 0, data);
            }
            IncrementLoggedMessagesCount(data);
        }

        static bool MatchFilters(Message message, MessageLoggingSource source)
        {
            bool result = true;
            if (MessageLogger.FilterMessages && (source & MessageLoggingSource.Malformed) == 0)
            {
                result = false;
                List<XPathMessageFilter> filtersToRemove = new List<XPathMessageFilter>();
                lock (MessageLogger.syncObject)
                {
                    foreach (XPathMessageFilter filter in MessageLogger.Filters)
                    {
                        try
                        {
                            if (filter.Match(message))
                            {
                                result = true;
                                break;
                            }
                        }
                        catch (FilterInvalidBodyAccessException)
                        {
                            filtersToRemove.Add(filter);
                        }
                        catch (MessageFilterException e)
                        {
                            if (DiagnosticUtility.ShouldTraceInformation)
                            {
                                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.FilterNotMatchedNodeQuotaExceeded,
                                    SR.GetString(SR.TraceCodeFilterNotMatchedNodeQuotaExceeded), e, message);
                            }
                        }
                    }

                    foreach (XPathMessageFilter filter in filtersToRemove)
                    {
                        MessageLogger.Filters.Remove(filter);
                        PlainXmlWriter writer = new PlainXmlWriter();
                        filter.WriteXPathTo(writer, null, ConfigurationStrings.Filter, null, true);
                        DiagnosticUtility.EventLog.LogEvent(TraceEventType.Error,
                            (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging,
                            (uint)System.Runtime.Diagnostics.EventLogEventId.RemovedBadFilter,
                            writer.Navigator.ToString());
                    }

                    if (MessageLogger.FilterCount == 0)
                    {
                        result = true;
                    }
                }
            }

            return result;
        }

        static void ReadFiltersFromConfig(DiagnosticSection section)
        {
            for (int i = 0; i < section.MessageLogging.Filters.Count; i++)
            {
                XPathMessageFilterElement xfe = section.MessageLogging.Filters[i];
                AddFilter(xfe.Filter);
            }
        }

        internal static TraceSource MessageTraceSource
        {
            get
            {
                return MessageLogger.messageTraceSource;
            }
        }

        internal static void EnsureInitialized()
        {
            lock (MessageLogger.syncObject)
            {
                if (!MessageLogger.initialized && !MessageLogger.initializing)
                {
                    try
                    {
                        Initialize();
                    }
#pragma warning suppress 56500 // covered by FxCOP
                    catch (SecurityException securityException)
                    {
                        // message logging is not support in PT, write the trace
                        MessageLogger.inPartialTrust = true;
                        if (DiagnosticUtility.ShouldTraceWarning)
                        {
                            TraceUtility.TraceEvent(TraceEventType.Warning,
                                TraceCode.TraceHandledException,
                                SR.GetString(SR.PartialTrustMessageLoggingNotEnabled),
                                null,
                                securityException);
                        }
                        // also write to event log
                        LogNonFatalInitializationException(
                            new SecurityException(
                                SR.GetString(SR.PartialTrustMessageLoggingNotEnabled),
                                securityException));
                        
                    }
                    MessageLogger.initialized = true;
                }
            }
        }

        static void EnsureMessageTraceSource()
        {
            if (!MessageLogger.initialized)
            {
                MessageLogger.EnsureInitialized();
            }
            if (null == MessageLogger.MessageTraceSource && !MessageLogger.attemptedTraceSourceInitialization)
            {
                InitializeMessageTraceSource();
            }
        }

        static string[][] PiiBodyPaths
        {
            get
            {
                if (piiBodyPaths == null)
                    piiBodyPaths = new string[][] { 
                                new string[] { MessageLogTraceRecord.MessageLogTraceRecordElementName, "Envelope", "Body", "RequestSecurityToken" },
                                new string[] { MessageLogTraceRecord.MessageLogTraceRecordElementName, "Envelope", "Body", "RequestSecurityTokenResponse" },
                                new string[] { MessageLogTraceRecord.MessageLogTraceRecordElementName, "Envelope", "Body", "RequestSecurityTokenResponseCollection" }
                            };
                return piiBodyPaths;
            }
        }

        static string[][] PiiHeadersPaths
        {
            get
            {
                if (piiHeadersPaths == null)
                    piiHeadersPaths = new string[][] { 
                                new string[] { MessageLogTraceRecord.MessageLogTraceRecordElementName, "Envelope", "Header", "Security" },
                                new string[] { MessageLogTraceRecord.MessageLogTraceRecordElementName, "Envelope", "Header", "IssuedTokens" }
                            };
                return piiHeadersPaths;
            }
        }

        static string[] SecurityActions
        {
            get
            {
                if (securityActions == null)
                    securityActions = new string[] { 
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue", 
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/Issue",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Renew",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/Renew",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Cancel",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/Cancel",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Validate",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/Validate",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/SCT",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/SCT",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/SCT/Amend",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/SCT/Amend",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/SCT/Renew",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/SCT/Renew",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/SCT/Cancel",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/SCT/Cancel",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RST/KET",
                                      "http://schemas.xmlsoap.org/ws/2005/02/trust/RSTR/KET",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/SCT",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/SCT",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/SCT-Amend",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/SCT-Amend",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/Issue",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/Issue",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/Renew",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/Renew",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/Validate",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/Validate",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RST/KET",
                                      "http://schemas.xmlsoap.org/ws/2004/04/security/trust/RSTR/KET"
                                    };
                return securityActions;
            }
        }

        [Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method UnsafeGetSection which elevates in order to load config.",
            Safe = "Does not leak any config objects.")]
        [SecuritySafeCritical]
        static void Initialize()
        {
            MessageLogger.initializing = true;
            DiagnosticSection section = DiagnosticSection.UnsafeGetSection();

            if (section != null)
            {
                MessageLogger.LogKnownPii = section.MessageLogging.LogKnownPii && MachineSettingsSection.EnableLoggingKnownPii;
                MessageLogger.LogMalformedMessages = section.MessageLogging.LogMalformedMessages;
                MessageLogger.LogMessageBody = section.MessageLogging.LogEntireMessage;
                MessageLogger.LogMessagesAtServiceLevel = section.MessageLogging.LogMessagesAtServiceLevel;
                MessageLogger.LogMessagesAtTransportLevel = section.MessageLogging.LogMessagesAtTransportLevel;
                MessageLogger.MaxNumberOfMessagesToLog = section.MessageLogging.MaxMessagesToLog;
                MessageLogger.MaxMessageSize = section.MessageLogging.MaxSizeOfMessageToLog;

                ReadFiltersFromConfig(section);
            }
        }

        static void InitializeMessageTraceSource()
        {
            try
            {
                MessageLogger.attemptedTraceSourceInitialization = true;
                PiiTraceSource tempSource = new PiiTraceSource(MessageLogger.MessageTraceSourceName, DiagnosticUtility.EventSourceName);
                tempSource.Switch.Level = SourceLevels.Information;
                tempSource.Listeners.Remove(MessageLogger.DefaultTraceListenerName);
                if (tempSource.Listeners.Count > 0)
                {
                    AppDomain.CurrentDomain.DomainUnload += new EventHandler(ExitOrUnloadEventHandler);
                    AppDomain.CurrentDomain.ProcessExit += new EventHandler(ExitOrUnloadEventHandler);
                    AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(ExitOrUnloadEventHandler);
                }
                else
                {
                    tempSource = null;
                }

                MessageLogger.messageTraceSource = tempSource;
            }
            catch (System.Configuration.ConfigurationErrorsException)
            {
                throw;
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (SecurityException securityException)
            {
                // message logging is not support in PT, write the trace
                MessageLogger.inPartialTrust = true;
                if (DiagnosticUtility.ShouldTraceWarning)
                {
                    TraceUtility.TraceEvent(TraceEventType.Warning,
                        TraceCode.TraceHandledException,
                        SR.GetString(SR.PartialTrustMessageLoggingNotEnabled),
                        null,
                        securityException);
                }
                // also write to event log
                LogNonFatalInitializationException(
                    new SecurityException(
                        SR.GetString(SR.PartialTrustMessageLoggingNotEnabled),
                        securityException));
            }
            catch (Exception e)
            {
                MessageLogger.messageTraceSource = null;

                if (Fx.IsFatal(e)) throw;

                LogNonFatalInitializationException(e);
            }
        }

        [Fx.Tag.SecurityNote(Critical = "Calls into an unsafe method to log event.",
            Safe = "Event identities cannot be spoofed as they are constants determined inside the method.")]
        [SecuritySafeCritical]
        static void LogNonFatalInitializationException(Exception e)
        {
            DiagnosticUtility.UnsafeEventLog.UnsafeLogEvent(TraceEventType.Critical,
                (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging,
                (uint)System.Runtime.Diagnostics.EventLogEventId.FailedToCreateMessageLoggingTraceSource,
                true,
                e.ToString());
        }

        static void ExitOrUnloadEventHandler(object sender, EventArgs e)
        {
            lock (MessageLogger.syncObject)
            {
                if (null != MessageLogger.MessageTraceSource)
                {
                    //Flush is called automatically on close by StreamWriter
                    MessageLogger.MessageTraceSource.Close();
                    MessageLogger.messageTraceSource = null;
                }
            }
        }

        static void ThrowIfNotMalformed(MessageLoggingSource source)
        {
            if ((source & MessageLoggingSource.Malformed) == 0)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.OnlyMalformedMessagesAreSupported), "source"));
            }
        }

        static void ProcessAudit(bool turningOn)
        {
            if (turningOn)
            {
                if (null != MessageLogger.messageTraceSource)
                {
                    DiagnosticUtility.EventLog.LogEvent(TraceEventType.Information,
                        (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging,
                    (uint)System.Runtime.Diagnostics.EventLogEventId.MessageLoggingOn);
                }
            }
            else
            {
                DiagnosticUtility.EventLog.LogEvent(TraceEventType.Information,
                    (ushort)System.Runtime.Diagnostics.EventLogCategory.MessageLogging,
                    (uint)System.Runtime.Diagnostics.EventLogEventId.MessageLoggingOff);
            }
        }

        static bool ShouldProcessAudit(MessageLoggingSource source, bool turningOn)
        {
            bool result = false;
            if (turningOn)
            {
                result = MessageLogger.sources == MessageLoggingSource.None;
            }
            else
            {
                result = MessageLogger.sources == source;
            }

            return result;
        }
    }
}