SecurityTraceRecordHelper.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Diagnostics / SecurityTraceRecordHelper.cs / 1 / SecurityTraceRecordHelper.cs

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

 
namespace System.ServiceModel.Diagnostics
{ 
    using System; 
    using System.ServiceModel.Channels;
    //using System.ServiceModel; 
    using System.ServiceModel.Dispatcher;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Globalization; 
    using System.Runtime.Serialization;
    using System.IdentityModel.Claims; 
    using System.IdentityModel.Policy; 
    using System.IdentityModel.Selectors;
    using System.IdentityModel.Tokens; 
    using System.Security.Principal;
    using System.ServiceModel.Security.Tokens;
    using System.ServiceModel.Security;
 
    using System.Text;
    using System.Xml; 
 

    internal class SecurityTraceRecord : TraceRecord 
    {
        String traceName;
        internal SecurityTraceRecord(String traceName)
        { 
            if (String.IsNullOrEmpty(traceName))
                this.traceName = "Empty"; 
            else 
                this.traceName = traceName;
        } 

        internal override string EventId
        {
            get 
            {
                return TraceRecord.EventIdBase + traceName + TraceRecord.NamespaceSuffix; 
            } 
        }
    } 

    internal static class SecurityTraceRecordHelper
    {
        internal static void TraceRemovedCachedServiceToken(IssuanceTokenProviderBase provider, SecurityToken serviceToken) 
            where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderRemovedCachedToken, SR.GetString(SR.TraceCodeIssuanceTokenProviderRemovedCachedToken), new IssuanceProviderTraceRecord(provider, serviceToken)); 
            }
        }

        internal static void TraceUsingCachedServiceToken(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target) 
             where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderUsingCachedToken, SR.GetString(SR.TraceCodeIssuanceTokenProviderUsingCachedToken), new IssuanceProviderTraceRecord(provider, serviceToken, target)); 
            }
        }

        internal static void TraceBeginSecurityNegotiation(IssuanceTokenProviderBase provider, EndpointAddress target) 
             where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderBeginSecurityNegotiation, SR.GetString(SR.TraceCodeIssuanceTokenProviderBeginSecurityNegotiation), new IssuanceProviderTraceRecord(provider, target)); 
            }
        }

        internal static void TraceEndSecurityNegotiation(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target) 
             where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderEndSecurityNegotiation, SR.GetString(SR.TraceCodeIssuanceTokenProviderEndSecurityNegotiation), new IssuanceProviderTraceRecord(provider, serviceToken, target)); 
            }
        }

        internal static void TraceRedirectApplied(IssuanceTokenProviderBase provider, EndpointAddress newTarget, EndpointAddress oldTarget) 
             where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderRedirectApplied, SR.GetString(SR.TraceCodeIssuanceTokenProviderRedirectApplied), new IssuanceProviderTraceRecord(provider, newTarget, oldTarget)); 
            }
        }

        internal static void TraceClientServiceTokenCacheFull(IssuanceTokenProviderBase provider, int cacheSize) 
             where T : IssuanceTokenProviderState
        { 
            if (DiagnosticUtility.ShouldTraceInformation) 
            {
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.IssuanceTokenProviderServiceTokenCacheFull, SR.GetString(SR.TraceCodeIssuanceTokenProviderServiceTokenCacheFull), new IssuanceProviderTraceRecord(provider, cacheSize)); 
            }
        }

        internal static void TraceClientSpnego(WindowsSspiNegotiation windowsNegotiation) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SpnegoClientNegotiationCompleted, SR.GetString(SR.TraceCodeSpnegoClientNegotiationCompleted), new WindowsSspiNegotiationTraceRecord(windowsNegotiation, true));
            } 
        }

        internal static void TraceServiceSpnego(WindowsSspiNegotiation windowsNegotiation)
        { 
            if (DiagnosticUtility.ShouldTraceInformation)
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SpnegoServiceNegotiationCompleted, SR.GetString(SR.TraceCodeSpnegoServiceNegotiationCompleted), new WindowsSspiNegotiationTraceRecord(windowsNegotiation, false)); 
            }
        } 

        internal static void TraceNegotiationTokenAuthenticatorAttached(NegotiationTokenAuthenticator authenticator, IChannelListener transportChannelListener)
            where T : NegotiationTokenAuthenticatorState
        { 
            if (DiagnosticUtility.ShouldTraceInformation)
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.NegotiationAuthenticatorAttached, SR.GetString(SR.TraceCodeNegotiationAuthenticatorAttached), new NegotiationAuthenticatorTraceRecord(authenticator, transportChannelListener)); 
            }
        } 

        internal static void TraceServiceSecurityNegotiationCompleted(NegotiationTokenAuthenticator authenticator, SecurityContextSecurityToken serviceToken)
            where T : NegotiationTokenAuthenticatorState
        { 
            if (DiagnosticUtility.ShouldTraceInformation)
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ServiceSecurityNegotiationCompleted, SR.GetString(SR.TraceCodeServiceSecurityNegotiationCompleted), 
                    new NegotiationAuthenticatorTraceRecord(authenticator, serviceToken));
            } 
        }

        internal static void TraceServiceSecurityNegotiationFailure(NegotiationTokenAuthenticator authenticator, Exception e)
            where T : NegotiationTokenAuthenticatorState 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityNegotiationProcessingFailure, SR.GetString(SR.TraceCodeSecurityNegotiationProcessingFailure), new NegotiationAuthenticatorTraceRecord(authenticator, e));
            } 
        }


        internal static void TraceSecurityContextTokenCacheFull(int capacity, int pruningAmount) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityContextTokenCacheFull, SR.GetString(SR.TraceCodeSecurityContextTokenCacheFull),
                    new SecurityContextTokenCacheTraceRecord(capacity, pruningAmount)); 
            }
        }

        internal static void TraceIdentityVerificationSuccess(EndpointIdentity identity, Claim claim, Type identityVerifier) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityVerificationSuccess, SR.GetString(SR.TraceCodeSecurityIdentityVerificationSuccess), new IdentityVerificationSuccessTraceRecord(identity, claim, identityVerifier)); 
        }
 
        internal static void TraceIdentityVerificationFailure(EndpointIdentity identity, AuthorizationContext authContext, Type identityVerifier)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityVerificationFailure, SR.GetString(SR.TraceCodeSecurityIdentityVerificationFailure), new IdentityVerificationFailureTraceRecord(identity, authContext, identityVerifier)); 
        }
 
        internal static void TraceIdentityDeterminationSuccess(EndpointAddress epr, EndpointIdentity identity, Type identityVerifier) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityDeterminationSuccess, SR.GetString(SR.TraceCodeSecurityIdentityDeterminationSuccess), new IdentityDeterminationSuccessTraceRecord(epr, identity, identityVerifier));
        }

        internal static void TraceIdentityDeterminationFailure(EndpointAddress epr, Type identityVerifier) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityDeterminationFailure, SR.GetString(SR.TraceCodeSecurityIdentityDeterminationFailure), new IdentityDeterminationFailureTraceRecord(epr, identityVerifier)); 
        }
 
        internal static void TraceIdentityHostNameNormalizationFailure(EndpointAddress epr, Type identityVerifier, Exception e)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityIdentityHostNameNormalizationFailure, SR.GetString(SR.TraceCodeSecurityIdentityHostNameNormalizationFailure), new IdentityHostNameNormalizationFailureTraceRecord(epr, identityVerifier, e)); 
        }
 
        internal static void TraceExportChannelBindingEntry() 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ExportSecurityChannelBindingEntry, SR.GetString(SR.TraceCodeExportSecurityChannelBindingEntry), null);
        }

        internal static void TraceExportChannelBindingExit() 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ExportSecurityChannelBindingExit, SR.GetString(SR.TraceCodeExportSecurityChannelBindingExit)); 
        }
 
        internal static void TraceImportChannelBindingEntry()
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ImportSecurityChannelBindingEntry, SR.GetString(SR.TraceCodeImportSecurityChannelBindingEntry), null); 
        }
 
        internal static void TraceImportChannelBindingExit() 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.ImportSecurityChannelBindingExit, SR.GetString(SR.TraceCodeImportSecurityChannelBindingExit));
        }

        internal static void TraceTokenProviderOpened(SecurityTokenProvider provider) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenProviderOpened, SR.GetString(SR.TraceCodeSecurityTokenProviderOpened), new TokenProviderTraceRecord(provider)); 
        }
 
        internal static void TraceTokenProviderClosed(SecurityTokenProvider provider)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenProviderClosed, SR.GetString(SR.TraceCodeSecurityTokenProviderClosed), new TokenProviderTraceRecord(provider)); 
        }
 
        internal static void TraceTokenAuthenticatorOpened(SecurityTokenAuthenticator authenticator) 
        {
            if (DiagnosticUtility.ShouldTraceVerbose) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose, TraceCode.SecurityTokenAuthenticatorOpened, SR.GetString(SR.TraceCodeSecurityTokenAuthenticatorOpened), new TokenAuthenticatorTraceRecord(authenticator));
        }

        internal static void TraceTokenAuthenticatorClosed(SecurityTokenAuthenticator authenticator) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityTokenAuthenticatorClosed, SR.GetString(SR.TraceCodeSecurityTokenAuthenticatorClosed), new TokenAuthenticatorTraceRecord(authenticator)); 
        }
 
        internal static void TraceOutgoingMessageSecured(SecurityProtocol binding, Message message)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SecurityBindingOutgoingMessageSecured, new MessageSecurityTraceRecord(binding, message), null, null, message); 
        }
 
        internal static void TraceIncomingMessageVerified(SecurityProtocol binding, Message message) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SecurityBindingIncomingMessageVerified, new MessageSecurityTraceRecord(binding, message), null, null, message);
        }

        internal static void TraceSecureOutgoingMessageFailure(SecurityProtocol binding, Message message) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityBindingSecureOutgoingMessageFailure, new MessageSecurityTraceRecord(binding, message), null, null, message); 
        }
 
        internal static void TraceVerifyIncomingMessageFailure(SecurityProtocol binding, Message message)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityBindingVerifyIncomingMessageFailure, new MessageSecurityTraceRecord(binding, message), null, null,message ); 
        }
 
        internal static void TraceSpnToSidMappingFailure(string spn, Exception e) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySpnToSidMappingFailure, SR.GetString(SR.TraceCodeSecuritySpnToSidMappingFailure), new SpnToSidMappingTraceRecord(spn, e));
        }

        internal static void TraceSessionRedirectApplied(EndpointAddress previousTarget, EndpointAddress newTarget, GenericXmlSecurityToken sessionToken) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRedirectApplied, SR.GetString(SR.TraceCodeSecuritySessionRedirectApplied), new SessionRedirectAppliedTraceRecord(previousTarget, newTarget, sessionToken)); 
        }
 
        internal static void TraceCloseMessageSent(SecurityToken sessionToken, EndpointAddress remoteTarget)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseSent, SR.GetString(SR.TraceCodeSecurityClientSessionCloseSent), new ClientSessionTraceRecord(sessionToken, null, remoteTarget)); 
        }
 
        internal static void TraceCloseResponseMessageSent(SecurityToken sessionToken, EndpointAddress remoteTarget) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseResponseSent, SR.GetString(SR.TraceCodeSecurityClientSessionCloseResponseSent), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
        }

        internal static void TraceCloseMessageReceived(SecurityToken sessionToken, EndpointAddress remoteTarget) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionCloseMessageReceived, SR.GetString(SR.TraceCodeSecurityClientSessionCloseMessageReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget)); 
        }
 
        internal static void TraceSessionKeyRenewalFault(SecurityToken sessionToken, EndpointAddress remoteTarget)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionKeyRenewalFaultReceived, SR.GetString(SR.TraceCodeSecuritySessionKeyRenewalFaultReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget)); 
        }
 
        internal static void TraceRemoteSessionAbortedFault(SecurityToken sessionToken, EndpointAddress remoteTarget) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionAbortedFaultReceived, SR.GetString(SR.TraceCodeSecuritySessionAbortedFaultReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget));
        }

        internal static void TraceCloseResponseReceived(SecurityToken sessionToken, EndpointAddress remoteTarget) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionClosedResponseReceived, SR.GetString(SR.TraceCodeSecuritySessionClosedResponseReceived), new ClientSessionTraceRecord(sessionToken, null, remoteTarget)); 
        }
 
        internal static void TracePreviousSessionKeyDiscarded(SecurityToken previousSessionToken, SecurityToken currentSessionToken, EndpointAddress remoteAddress)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionPreviousKeyDiscarded, SR.GetString(SR.TraceCodeSecurityClientSessionPreviousKeyDiscarded), new ClientSessionTraceRecord(currentSessionToken, previousSessionToken, remoteAddress)); 
        }
 
        internal static void TraceSessionKeyRenewed(SecurityToken newSessionToken, SecurityToken currentSessionToken, EndpointAddress remoteAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityClientSessionKeyRenewed, SR.GetString(SR.TraceCodeSecurityClientSessionKeyRenewed), new ClientSessionTraceRecord(newSessionToken, currentSessionToken, remoteAddress));
        }

        internal static void TracePendingSessionAdded(UniqueId sessionId, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityPendingServerSessionAdded, SR.GetString(SR.TraceCodeSecurityPendingServerSessionAdded), new ServerSessionTraceRecord(sessionId, listenAddress)); 
        }
 
        internal static void TracePendingSessionClosed(UniqueId sessionId, Uri listenAddress)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityPendingServerSessionClosed, SR.GetString(SR.TraceCodeSecurityPendingServerSessionClosed), new ServerSessionTraceRecord(sessionId, listenAddress)); 
        }
 
        internal static void TracePendingSessionActivated(UniqueId sessionId, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityPendingServerSessionActivated, SR.GetString(SR.TraceCodeSecurityPendingServerSessionActivated), new ServerSessionTraceRecord(sessionId, listenAddress));
        }

        internal static void TraceActiveSessionRemoved(UniqueId sessionId, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityActiveServerSessionRemoved, SR.GetString(SR.TraceCodeSecurityActiveServerSessionRemoved), new ServerSessionTraceRecord(sessionId, listenAddress)); 
        }
 
        internal static void TraceNewServerSessionKeyIssued(SecurityContextSecurityToken newToken, SecurityContextSecurityToken supportingToken, Uri listenAddress)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityNewServerSessionKeyIssued, SR.GetString(SR.TraceCodeSecurityNewServerSessionKeyIssued), new ServerSessionTraceRecord(newToken, supportingToken, listenAddress)); 
        }
 
        internal static void TraceInactiveSessionFaulted(SecurityContextSecurityToken sessionToken, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityInactiveSessionFaulted, SR.GetString(SR.TraceCodeSecurityInactiveSessionFaulted), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken) null, listenAddress));
        }

        internal static void TraceServerSessionKeyUpdated(SecurityContextSecurityToken sessionToken, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionKeyUpdated, SR.GetString(SR.TraceCodeSecurityServerSessionKeyUpdated), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress)); 
        }
 
        internal static void TraceServerSessionCloseReceived(SecurityContextSecurityToken sessionToken, Uri listenAddress)
        {
            if (DiagnosticUtility.ShouldTraceInformation)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionCloseReceived, SR.GetString(SR.TraceCodeSecurityServerSessionCloseReceived), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress)); 
        }
 
        internal static void TraceServerSessionCloseResponseReceived(SecurityContextSecurityToken sessionToken, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityServerSessionCloseResponseReceived, SR.GetString(SR.TraceCodeSecurityServerSessionCloseResponseReceived), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
        }

        internal static void TraceSessionRenewalFaultSent(SecurityContextSecurityToken sessionToken, Uri listenAddress, Message message) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.SecurityServerSessionRenewalFaultSent, new ServerSessionTraceRecord(sessionToken, message, listenAddress), null, null, message); 
        }
 
        internal static void TraceSessionAbortedFaultSent(SecurityContextSecurityToken sessionToken, Uri listenAddress)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityServerSessionAbortedFaultSent, SR.GetString(SR.TraceCodeSecurityServerSessionAbortedFaultSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress)); 
        }
 
        internal static void TraceSessionClosedResponseSent(SecurityContextSecurityToken sessionToken, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionCloseResponseSent, SR.GetString(SR.TraceCodeSecuritySessionCloseResponseSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress));
        }

        internal static void TraceSessionClosedSent(SecurityContextSecurityToken sessionToken, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionServerCloseSent, SR.GetString(SR.TraceCodeSecuritySessionServerCloseSent), new ServerSessionTraceRecord(sessionToken, (SecurityContextSecurityToken)null, listenAddress)); 
        }
 
        internal static void TraceRenewFaultSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionRenewFaultSendFailure, SR.GetString(SR.TraceCodeSecuritySessionRenewFaultSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e); 
        }
 
        internal static void TraceSessionAbortedFaultSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionAbortedFaultSendFailure, SR.GetString(SR.TraceCodeSecuritySessionAbortedFaultSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e);
        }

        internal static void TraceSessionClosedResponseSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionClosedResponseSendFailure, SR.GetString(SR.TraceCodeSecuritySessionClosedResponseSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e); 
        }
 
        internal static void TraceSessionCloseSendFailure(SecurityContextSecurityToken sessionToken, Uri listenAddress, Exception e)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionServerCloseSendFailure, SR.GetString(SR.TraceCodeSecuritySessionServerCloseSendFailure), new ServerSessionTraceRecord(sessionToken, listenAddress), e); 
        }
 
        internal static void TraceBeginSecuritySessionOperation(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRequestorStartOperation, SR.GetString(SR.TraceCodeSecuritySessionRequestorStartOperation), new SessionRequestorTraceRecord(operation, currentToken, (GenericXmlSecurityToken)null, target));
        }

        internal static void TraceSecuritySessionOperationSuccess(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, SecurityToken issuedToken) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecuritySessionRequestorOperationSuccess, SR.GetString(SR.TraceCodeSecuritySessionRequestorOperationSuccess), new SessionRequestorTraceRecord(operation, currentToken, issuedToken, target)); 
        }
 
        internal static void TraceSecuritySessionOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionRequestorOperationFailure, SR.GetString(SR.TraceCodeSecuritySessionRequestorOperationFailure), new SessionRequestorTraceRecord(operation, currentToken, e, target)); 
        }
 
        internal static void TraceServerSessionOperationException(SecuritySessionOperation operation, Exception e, Uri listenAddress) 
        {
            if (DiagnosticUtility.ShouldTraceWarning) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecuritySessionResponderOperationFailure, SR.GetString(SR.TraceCodeSecuritySessionResponderOperationFailure), new SessionResponderTraceRecord(operation, e, listenAddress));
        }

        internal static void TraceImpersonationSucceeded(DispatchOperationRuntime operation) 
        {
            if (DiagnosticUtility.ShouldTraceInformation) 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, TraceCode.SecurityImpersonationSuccess, SR.GetString(SR.TraceCodeSecurityImpersonationSuccess), new ImpersonationTraceRecord(operation)); 
        }
 
        internal static void TraceImpersonationFailed(DispatchOperationRuntime operation, Exception e)
        {
            if (DiagnosticUtility.ShouldTraceWarning)
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, TraceCode.SecurityImpersonationFailure, SR.GetString(SR.TraceCodeSecurityImpersonationFailure), new ImpersonationTraceRecord(operation), e); 
        }
 
        static void WritePossibleGenericXmlToken(XmlWriter writer, string startElement, SecurityToken token) 
        {
            if (writer == null) 
                return;

            writer.WriteStartElement(startElement);
            GenericXmlSecurityToken gxt = token as GenericXmlSecurityToken; 
            if (gxt != null)
            { 
                WriteGenericXmlToken(writer, gxt); 
            }
            else 
            {
                if (token != null)
                    writer.WriteElementString("TokenType", token.GetType().ToString());
            } 
            writer.WriteEndElement();
        } 
 
        static void WriteGenericXmlToken(XmlWriter xml, SecurityToken sessiontoken)
        { 
            if (xml == null || sessiontoken == null)
                return;
            xml.WriteElementString("SessionTokenType", sessiontoken.GetType().ToString());
            xml.WriteElementString("ValidFrom", XmlConvert.ToString(sessiontoken.ValidFrom, XmlDateTimeSerializationMode.Utc)); 
            xml.WriteElementString("ValidTo", XmlConvert.ToString(sessiontoken.ValidTo, XmlDateTimeSerializationMode.Utc));
            GenericXmlSecurityToken token = sessiontoken as GenericXmlSecurityToken; 
            if (token != null) 
            {
                if (token.InternalTokenReference != null) 
                {
                    xml.WriteElementString("InternalTokenReference", token.InternalTokenReference.ToString());
                }
                if (token.ExternalTokenReference != null) 
                {
                    xml.WriteElementString("ExternalTokenReference", token.ExternalTokenReference.ToString()); 
                } 
                xml.WriteElementString("IssuedTokenElementName", token.TokenXml.LocalName);
                xml.WriteElementString("IssuedTokenElementNamespace", token.TokenXml.NamespaceURI); 
            }
        }

        static void WriteSecurityContextToken(XmlWriter xml, SecurityContextSecurityToken token) 
        {
 
            xml.WriteElementString("ContextId", token.ContextId.ToString()); 
            if (token.KeyGeneration != null)
            { 
                xml.WriteElementString("KeyGeneration", token.KeyGeneration.ToString());
            }
        }
 
        static internal void WriteClaim(XmlWriter xml, Claim claim)
        { 
            if (xml == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xml");
 
            if (claim != null)
            {
                xml.WriteStartElement("Claim");
 
                if (null != DiagnosticUtility.DiagnosticTrace
                    && null != DiagnosticUtility.DiagnosticTrace.TraceSource 
                    && DiagnosticUtility.DiagnosticTrace.TraceSource.ShouldLogPii) 
                {
                    // 
                    // ClaimType
                    //
                    xml.WriteElementString("ClaimType", claim.ClaimType);
 
                    //
                    // Right 
                    // 
                    xml.WriteElementString("Right", claim.Right);
 
                    //
                    // Resource object type: most of time, it is a System.String
                    //
                    if (claim.Resource != null) 
                        xml.WriteElementString("ResourceType", claim.Resource.GetType().ToString());
                    else 
                        xml.WriteElementString("Resource", "null"); 
                }
                else 
                {
                    xml.WriteString(claim.GetType().AssemblyQualifiedName);
                }
 

                xml.WriteEndElement(); 
            } 
        }
 
        class SessionResponderTraceRecord : SecurityTraceRecord
        {
            SecuritySessionOperation operation;
            Exception e; 
            Uri listenAddress;
 
            public SessionResponderTraceRecord(SecuritySessionOperation operation, Exception e, Uri listenAddress) 
                : base("SecuritySession")
            { 
                this.operation = operation;
                this.e = e;
                this.listenAddress = listenAddress;
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            { 
                if (xml == null)
                    return; 

                xml.WriteElementString("Operation", this.operation.ToString());

                if (this.e != null) 
                {
                    xml.WriteElementString("Exception", e.ToString()); 
                } 

                if (this.listenAddress != null) 
                    xml.WriteElementString("ListenAddress", this.listenAddress.ToString());
            }
        }
 
        class SessionRequestorTraceRecord : SecurityTraceRecord
        { 
            SecuritySessionOperation operation; 
            SecurityToken currentToken;
            SecurityToken issuedToken; 
            EndpointAddress target;
            Exception e;

            public SessionRequestorTraceRecord(SecuritySessionOperation operation, SecurityToken currentToken, SecurityToken issuedToken, EndpointAddress target) 
                : base("SecuritySession")
            { 
                this.operation = operation; 
                this.currentToken = currentToken;
                this.issuedToken = issuedToken; 
                this.target = target;
            }

            public SessionRequestorTraceRecord(SecuritySessionOperation operation, SecurityToken currentToken, Exception e, EndpointAddress target) 
                : base("SecuritySession")
            { 
                this.operation = operation; 
                this.currentToken = currentToken;
                this.e = e; 
                this.target = target;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                xml.WriteElementString("Operation", this.operation.ToString()); 

                if (this.currentToken != null)
                {
                    WritePossibleGenericXmlToken(xml, "SupportingToken", this.currentToken); 
                }
                if (this.issuedToken != null) 
                { 
                    WritePossibleGenericXmlToken(xml, "IssuedToken", this.issuedToken);
                } 
                if (this.e != null)
                {
                    xml.WriteElementString("Exception", e.ToString());
                } 
                if (this.target != null)
                { 
                    xml.WriteElementString("RemoteAddress", this.target.ToString()); 
                }
            } 
        }

        class ServerSessionTraceRecord : SecurityTraceRecord
        { 
            SecurityContextSecurityToken currentSessionToken;
            SecurityContextSecurityToken newSessionToken; 
            UniqueId sessionId; 
            Message message;
            Uri listenAddress; 

            public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, SecurityContextSecurityToken newSessionToken, Uri listenAddress)
                : base("SecuritySession")
            { 
                this.currentSessionToken = currentSessionToken;
                this.newSessionToken = newSessionToken; 
                this.listenAddress = listenAddress; 
            }
 
            public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, Message message, Uri listenAddress)
                : base("SecuritySession")
            {
                this.currentSessionToken = currentSessionToken; 
                this.message = message;
                this.listenAddress = listenAddress; 
            } 

            public ServerSessionTraceRecord(SecurityContextSecurityToken currentSessionToken, Uri listenAddress) 
                : base("SecuritySession")
            {
                this.currentSessionToken = currentSessionToken;
                this.listenAddress = listenAddress; 
            }
 
            public ServerSessionTraceRecord(UniqueId sessionId, Uri listenAddress) 
                : base("SecuritySession")
            { 
                this.sessionId = sessionId;
                this.listenAddress = listenAddress;
            }
 
            internal override void WriteTo(System.Xml.XmlWriter xml)
            { 
                if (xml == null) 
                    return;
 
                if (this.currentSessionToken != null)
                {
                    xml.WriteStartElement("CurrentSessionToken");
                    WriteSecurityContextToken(xml, this.currentSessionToken); 
                    xml.WriteEndElement();
                } 
                if (this.newSessionToken != null) 
                {
                    xml.WriteStartElement("NewSessionToken"); 
                    WriteSecurityContextToken(xml, this.newSessionToken);
                    xml.WriteEndElement();
                }
                if (this.sessionId != null) 
                {
                    XmlHelper.WriteElementStringAsUniqueId(xml, "SessionId", this.sessionId); 
                } 
                if (this.message != null)
                { 
                    xml.WriteElementString("MessageAction", message.Headers.Action);
                }
                if (this.listenAddress != null)
                { 
                    xml.WriteElementString("ListenAddress", this.listenAddress.ToString());
                } 
            } 
        }
 
        class ClientSessionTraceRecord : SecurityTraceRecord
        {
            SecurityToken currentSessionToken;
            SecurityToken previousSessionToken; 
            EndpointAddress remoteAddress;
 
            public ClientSessionTraceRecord(SecurityToken currentSessionToken, SecurityToken previousSessionToken, EndpointAddress remoteAddress) 
                : base("SecuritySession")
            { 
                this.currentSessionToken = currentSessionToken;
                this.previousSessionToken = previousSessionToken;
                this.remoteAddress = remoteAddress;
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            { 
                if (xml == null)
                    return; 

                if (this.remoteAddress != null)
                    xml.WriteElementString("RemoteAddress", remoteAddress.ToString());
 
                if (this.currentSessionToken != null)
                { 
                    xml.WriteStartElement("CurrentSessionToken"); 
                    WriteGenericXmlToken(xml, this.currentSessionToken);
                    xml.WriteEndElement(); 
                }
                if (this.previousSessionToken != null)
                {
                    xml.WriteStartElement("PreviousSessionToken"); 
                    WriteGenericXmlToken(xml, this.previousSessionToken);
                    xml.WriteEndElement(); 
                } 
            }
        } 

        class SessionRedirectAppliedTraceRecord : SecurityTraceRecord
        {
            EndpointAddress previousTarget; 
            EndpointAddress newTarget;
            GenericXmlSecurityToken sessionToken; 
 
            public SessionRedirectAppliedTraceRecord(EndpointAddress previousTarget, EndpointAddress newTarget, GenericXmlSecurityToken sessionToken)
                : base("SecuritySession") 
            {
                this.previousTarget = previousTarget;
                this.newTarget = newTarget;
                this.sessionToken = sessionToken; 
            }
 
            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return;

                if (this.previousTarget != null)
                    xml.WriteElementString("OriginalRemoteAddress", this.previousTarget.ToString()); 

                if (this.newTarget != null) 
                    xml.WriteElementString("NewRemoteAddress", this.newTarget.ToString()); 

                if (this.sessionToken != null) 
                {
                    xml.WriteStartElement("SessionToken");
                    WriteGenericXmlToken(xml, this.sessionToken);
                    xml.WriteEndElement(); 
                }
            } 
        } 

        class SpnToSidMappingTraceRecord : SecurityTraceRecord 
        {
            string spn;
            Exception e;
 
            public SpnToSidMappingTraceRecord(string spn, Exception e)
                : base("SecurityIdentity") 
            { 
               this.spn = spn;
               this.e = e; 
            }

            internal override void WriteTo(System.Xml.XmlWriter xml)
            { 
                if (xml == null)
                    return; 
 
                if (this.spn != null)
                    xml.WriteElementString("ServicePrincipalName", this.spn); 

                if (this.e != null)
                   xml.WriteElementString("Exception", this.e.ToString());
            } 
        }
 
        class MessageSecurityTraceRecord : SecurityTraceRecord 
        {
            SecurityProtocol binding; 
            Message message;

            public MessageSecurityTraceRecord(SecurityProtocol binding, Message message)
                : base("SecurityProtocol") 
            {
                this.binding = binding; 
                this.message = message; 
            }
 
            internal override void WriteTo(System.Xml.XmlWriter xml)
            {
                if (xml == null)
                    return; 

                if (this.binding != null) 
                    xml.WriteElementString("SecurityProtocol", this.binding.ToString()); 

                if (this.message != null) 
                {
                    string action = this.message.Headers.Action;
                    Uri to = this.message.Headers.To;
                    EndpointAddress replyTo = this.message.Headers.ReplyTo; 
                    UniqueId id = this.message.Headers.MessageId;
                    if (!String.IsNullOrEmpty(action)) 
                    { 
                        xml.WriteElementString("Action", action);
                    } 
                    if (to != null)
                    {
                        xml.WriteElementString("To", to.AbsoluteUri);
                    } 
                    if (replyTo != null)
                    { 
                        replyTo.WriteTo(this.message.Version.Addressing, xml); 
                    }
                    if (id != null) 
                    {
                        xml.WriteElementString("MessageId", id.ToString());
                    }
                } 
                else
                { 
                    xml.WriteElementString("Message", "null"); 
                }
            } 
        }

        class TokenProviderTraceRecord : SecurityTraceRecord
        { 
            SecurityTokenProvider provider;
 
            public TokenProviderTraceRecord(SecurityTokenProvider provider) 
                : base("SecurityTokenProvider")
            { 
                this.provider = provider;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                if (this.provider != null) 
                    xml.WriteElementString("SecurityTokenProvider", this.provider.ToString());
            }
        }
 
        class TokenAuthenticatorTraceRecord : SecurityTraceRecord
        { 
            SecurityTokenAuthenticator authenticator; 

            public TokenAuthenticatorTraceRecord(SecurityTokenAuthenticator authenticator) 
                : base("SecurityTokenAuthenticator")
            {
                this.authenticator = authenticator;
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            { 
                if (xml == null)
                    return; 

                if (this.authenticator != null)
                    xml.WriteElementString("SecurityTokenAuthenticator", this.authenticator.ToString());
            } 
        }
 
        class SecurityContextTokenCacheTraceRecord : SecurityTraceRecord 
        {
            int capacity; 
            int pruningAmount;

            public SecurityContextTokenCacheTraceRecord(int capacity, int pruningAmount)
                : base("ServiceSecurityNegotiation") 
            {
                this.capacity = capacity; 
                this.pruningAmount = pruningAmount; 
            }
 
            internal override void WriteTo(System.Xml.XmlWriter xml)
            {
                if (xml == null)
                    return; 

                xml.WriteElementString("Capacity", this.capacity.ToString(NumberFormatInfo.InvariantInfo)); 
                xml.WriteElementString("PruningAmount", this.pruningAmount.ToString(NumberFormatInfo.InvariantInfo)); 
            }
        } 

        class NegotiationAuthenticatorTraceRecord : SecurityTraceRecord
            where T : NegotiationTokenAuthenticatorState
        { 
            NegotiationTokenAuthenticator authenticator;
            IChannelListener transportChannelListener; 
            SecurityContextSecurityToken serviceToken; 
            Exception e;
 
            public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, IChannelListener transportChannelListener)
                : base("NegotiationTokenAuthenticator")
            {
                this.authenticator = authenticator; 
                this.transportChannelListener = transportChannelListener;
            } 
 
            public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, Exception e)
                : base("NegotiationTokenAuthenticator") 
            {
                this.authenticator = authenticator;
                this.e = e;
            } 

            public NegotiationAuthenticatorTraceRecord(NegotiationTokenAuthenticator authenticator, SecurityContextSecurityToken serviceToken) 
                : base("NegotiationTokenAuthenticator") 
            {
                this.authenticator = authenticator; 
                this.serviceToken = serviceToken;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                if (this.authenticator != null) 
                    xml.WriteElementString("NegotiationTokenAuthenticator", DiagnosticTrace.XmlEncode(this.authenticator.ToString()));

                if (this.authenticator != null && this.authenticator.ListenUri != null)
                    xml.WriteElementString("AuthenticatorListenUri", this.authenticator.ListenUri.AbsoluteUri); 

                if (this.serviceToken != null) 
                { 
                    xml.WriteStartElement("SecurityContextSecurityToken");
                    WriteSecurityContextToken(xml, this.serviceToken); 
                    xml.WriteEndElement();
                }
                if (this.transportChannelListener != null)
                { 
                    xml.WriteElementString("TransportChannelListener", DiagnosticTrace.XmlEncode(this.transportChannelListener.ToString()));
 
                    if (this.transportChannelListener.Uri != null) 
                        xml.WriteElementString("ListenUri", this.transportChannelListener.Uri.AbsoluteUri);
                } 
                if (this.e != null)
                {
                    xml.WriteElementString("Exception", DiagnosticTrace.XmlEncode(e.ToString()));
                } 
            }
        } 
 
        class IdentityVerificationSuccessTraceRecord : SecurityTraceRecord
        { 
            EndpointIdentity identity;
            Claim claim;
            Type identityVerifier;
 
            public IdentityVerificationSuccessTraceRecord(EndpointIdentity identity, Claim claim, Type identityVerifier)
                : base("ServiceIdentityVerification") 
            { 
                this.identity = identity;
                this.claim = claim; 
                this.identityVerifier = identityVerifier;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateDictionaryWriter(xml); 

                if (this.identityVerifier != null)
                    xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
 
                if (this.identity != null)
                    this.identity.WriteTo(xmlWriter); 
 
                if (this.claim != null)
                    SecurityTraceRecordHelper.WriteClaim(xmlWriter, this.claim); 
            }
        }

        class IdentityVerificationFailureTraceRecord : SecurityTraceRecord 
        {
            EndpointIdentity identity; 
            AuthorizationContext authContext; 
            Type identityVerifier;
 
            public IdentityVerificationFailureTraceRecord(EndpointIdentity identity, AuthorizationContext authContext, Type identityVerifier)
                : base("ServiceIdentityVerification")
            {
                this.identity = identity; 
                this.authContext = authContext;
                this.identityVerifier = identityVerifier; 
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null)
                    return;
 
                XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateDictionaryWriter(xml);
 
                if (this.identityVerifier != null) 
                    xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());
 
                if (this.identity != null)
                    this.identity.WriteTo(xmlWriter);

                if (this.authContext != null) 
                {
                    for (int i = 0; i < this.authContext.ClaimSets.Count; ++i) 
                    { 
                        ClaimSet claimSet = this.authContext.ClaimSets[i];
                        if (this.authContext.ClaimSets[i] == null) 
                            continue;

                        for (int j = 0; j < claimSet.Count; ++j)
                        { 
                            Claim claim = claimSet[j];
                            if (claimSet[j] == null) 
                                continue; 

                            xml.WriteStartElement("Claim"); 

                            // currently ClaimType and Right cannot be null.  Just being defensive
                            if (claim.ClaimType != null)
                                xml.WriteElementString("ClaimType", claim.ClaimType); 
                            else
                                xml.WriteElementString("ClaimType","null"); 
 
                            if (claim.Right != null)
                                xml.WriteElementString("Right", claim.Right); 
                            else
                                xml.WriteElementString("Right", "null");

                            if (claim.Resource != null) 
                                xml.WriteElementString("ResourceType", claim.Resource.GetType().ToString());
                            else 
                                xml.WriteElementString("Resource", "null"); 

                            xml.WriteEndElement(); 
                        }
                    }
                }
            } 
        }
 
        class IdentityDeterminationSuccessTraceRecord : SecurityTraceRecord 
        {
            EndpointIdentity identity; 
            EndpointAddress epr;
            Type identityVerifier;

            public IdentityDeterminationSuccessTraceRecord(EndpointAddress epr, EndpointIdentity identity, Type identityVerifier) 
                : base("ServiceIdentityDetermination")
            { 
                this.identity = identity; 
                this.epr = epr;
                this.identityVerifier = identityVerifier; 
            }

            internal override void WriteTo(System.Xml.XmlWriter xml)
            { 
                if (xml == null)
                    return; 
 
                if (this.identityVerifier != null)
                    xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString()); 

                if (this.identity != null)
                    this.identity.WriteTo(XmlDictionaryWriter.CreateDictionaryWriter(xml));
 
                if (this.epr != null)
                    this.epr.WriteTo(AddressingVersion.WSAddressing10, xml); 
            } 
        }
 
        class IdentityDeterminationFailureTraceRecord : SecurityTraceRecord
        {
            Type identityVerifier;
            EndpointAddress epr; 

            public IdentityDeterminationFailureTraceRecord(EndpointAddress epr, Type identityVerifier) 
                : base("ServiceIdentityDetermination") 
            {
                this.epr = epr; 
                this.identityVerifier = identityVerifier;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                if (this.identityVerifier != null) 
                    xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());

                if (this.epr != null)
                    this.epr.WriteTo(AddressingVersion.WSAddressing10, xml); 
            }
        } 
 
        class IdentityHostNameNormalizationFailureTraceRecord : SecurityTraceRecord
        { 
            Type identityVerifier;
            Exception e;
            EndpointAddress epr;
 
            public IdentityHostNameNormalizationFailureTraceRecord(EndpointAddress epr, Type identityVerifier, Exception e)
                : base("ServiceIdentityDetermination") 
            { 
                this.epr = epr;
                this.identityVerifier = identityVerifier; 
                this.e = e;
            }

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            {
                if (xml == null) 
                    return; 

                if (this.identityVerifier != null) 
                    xml.WriteElementString("IdentityVerifierType", this.identityVerifier.ToString());

                if (this.epr != null)
                    this.epr.WriteTo(AddressingVersion.WSAddressing10, xml); 

                if (e != null) 
                    xml.WriteElementString("Exception", e.ToString()); 
            }
        } 

        class IssuanceProviderTraceRecord : SecurityTraceRecord
           where T : IssuanceTokenProviderState
        { 
            IssuanceTokenProviderBase provider;
            EndpointAddress target; 
            EndpointAddress newTarget; 
            SecurityToken serviceToken;
            int cacheSize; 

            public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, SecurityToken serviceToken)
                : this(provider, serviceToken, null)
            { } 

            public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, EndpointAddress target) 
                : this(provider, (SecurityToken) null, target) 
            { }
 
            public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, SecurityToken serviceToken, EndpointAddress target)
                : base("ClientSecurityNegotiation")
            {
                this.provider = provider; 
                this.serviceToken = serviceToken;
                this.target = target; 
            } 

            public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, EndpointAddress newTarget, EndpointAddress oldTarget) 
                : base("ClientSecurityNegotiation")
            {
                this.provider = provider;
                this.newTarget = newTarget; 
                this.target = oldTarget;
            } 
 
            public IssuanceProviderTraceRecord(IssuanceTokenProviderBase provider, int cacheSize)
                : base("ClientSecurityNegotiation") 
            {
                this.provider = provider;
                this.cacheSize = cacheSize;
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            { 
                if (xml == null)
                    return; 

                if (this.provider != null)
                    xml.WriteElementString("IssuanceTokenProvider", this.provider.ToString());
 
                if (this.serviceToken != null)
                    WritePossibleGenericXmlToken(xml, "ServiceToken", this.serviceToken); 
 

                if (this.target != null) 
                {
                    xml.WriteStartElement("Target");
                    this.target.WriteTo(AddressingVersion.WSAddressing10, xml);
                    xml.WriteEndElement(); 
                }
 
                if (this.newTarget != null) 
                {
                    xml.WriteStartElement("PinnedTarget"); 
                    this.newTarget.WriteTo(AddressingVersion.WSAddressing10, xml);
                    xml.WriteEndElement();
                }
 
                if (this.cacheSize != 0)
                { 
                    xml.WriteElementString("CacheSize", this.cacheSize.ToString(NumberFormatInfo.InvariantInfo)); 
                }
            } 
        }

        class WindowsSspiNegotiationTraceRecord : SecurityTraceRecord
        { 
            WindowsSspiNegotiation windowsNegotiation;
            bool isClient; 
 
            public WindowsSspiNegotiationTraceRecord(WindowsSspiNegotiation windowsNegotiation, bool isClient)
                : base("SpnegoSecurityNegotiation") 
            {
                this.windowsNegotiation = windowsNegotiation;
                this.isClient = isClient;
            } 

            internal override void WriteTo(System.Xml.XmlWriter xml) 
            { 
                if (xml == null)
                    return; 

                if (this.windowsNegotiation != null)
                {
                    xml.WriteElementString("Protocol", this.windowsNegotiation.ProtocolName); 

 
                    if (isClient) 
                    {
                        xml.WriteElementString("ServicePrincipalName", this.windowsNegotiation.ServicePrincipalName); 
                        xml.WriteElementString("MutualAuthentication", this.windowsNegotiation.IsMutualAuthFlag.ToString());
                    }
                    else
                    { 
                        if (this.windowsNegotiation.IsIdentifyFlag)
                        { 
                            xml.WriteElementString("ImpersonationLevel", "Identify"); 
                        }
                        else if (this.windowsNegotiation.IsDelegationFlag) 
                        {
                            xml.WriteElementString("ImpersonationLevel", "Delegate");
                        }
                        else 
                        {
                            xml.WriteElementString("ImpersonationLevel", "Impersonate"); 
                        } 
                    }
                } 
            }
        }

        class ImpersonationTraceRecord : SecurityTraceRecord 
        {
            private DispatchOperationRuntime operation; 
 
            internal ImpersonationTraceRecord(DispatchOperationRuntime operation)
                : base ("SecurityImpersonation") 
            {
                this.operation = operation;
            }
 
            internal override void WriteTo(System.Xml.XmlWriter xml)
            { 
                if (xml == null) 
                {
                    // We are inside tracing. Don't throw an exception here just 
                    // return.
                    return;
                }
 
                if (this.operation != null)
                { 
                    xml.WriteElementString("OperationAction", this.operation.Action); 
                    xml.WriteElementString("OperationName", this.operation.Name);
                } 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK