mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Security/ImpersonatingMessage.cs

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Security
{
    using System.Security.Principal;
    using System.ServiceModel.Channels;
    using System.Xml;

    sealed class ImpersonatingMessage : Message
    {
        Message innerMessage;

        public ImpersonatingMessage(Message innerMessage)
        {
            if (innerMessage == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("innerMessage");
            }
            this.innerMessage = innerMessage;
        }

        public override bool IsEmpty
        {
            get
            {
                return this.innerMessage.IsEmpty;
            }
        }

        public override bool IsFault
        {
            get { return this.innerMessage.IsFault; }
        }

        public override MessageHeaders Headers
        {
            get { return this.innerMessage.Headers; }
        }

        public override MessageProperties Properties
        {
            get { return this.innerMessage.Properties; }
        }

        public override MessageVersion Version
        {
            get { return this.innerMessage.Version; }
        }

        internal override RecycledMessageState RecycledMessageState
        {
            get
            {
                return this.innerMessage.RecycledMessageState;
            }
        }

        protected override void OnClose()
        {
            base.OnClose();
            this.innerMessage.Close();
        }

        //Runs impersonated.
        protected override IAsyncResult OnBeginWriteMessage(XmlDictionaryWriter writer, AsyncCallback callback, object state)
        {
            ImpersonateOnSerializingReplyMessageProperty impersonationProperty = null;
            IDisposable impersonationContext = null;
            IPrincipal originalPrincipal = null;
            bool isThreadPrincipalSet = false;

            if (!ImpersonateOnSerializingReplyMessageProperty.TryGet(this.innerMessage, out impersonationProperty))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnableToImpersonateWhileSerializingReponse)));
            }

            try
            {
                impersonationProperty.StartImpersonation(out impersonationContext, out originalPrincipal, out isThreadPrincipalSet);
                return this.innerMessage.BeginWriteMessage(writer, callback, state);
            }
            finally
            {
                try
                {
                    impersonationProperty.StopImpersonation(impersonationContext, originalPrincipal, isThreadPrincipalSet);
                }
#pragma warning suppress 56500 // covered by FxCOP
                catch
                {
                    string message = null;
                    try
                    {
                        message = SR.GetString(SR.SFxRevertImpersonationFailed0);
                    }
                    finally
                    {
                        DiagnosticUtility.FailFast(message);
                    }
                }
            }
        }

        //Runs impersonated.
        protected override void OnWriteMessage(XmlDictionaryWriter writer)
        {
            this.ImpersonateCall(() => this.innerMessage.WriteMessage(writer));
        }
     
        protected override void OnEndWriteMessage(IAsyncResult result)
        {
            this.innerMessage.EndWriteMessage(result);
        }

        protected override void OnWriteStartEnvelope(XmlDictionaryWriter writer)
        {
            this.innerMessage.WriteStartEnvelope(writer);
        }

        protected override void OnWriteStartHeaders(XmlDictionaryWriter writer)
        {
            this.innerMessage.WriteStartHeaders(writer);
        }

        protected override void OnWriteStartBody(XmlDictionaryWriter writer)
        {
            this.innerMessage.WriteStartBody(writer);
        }

        protected override string OnGetBodyAttribute(string localName, string ns)
        {
            return this.innerMessage.GetBodyAttribute(localName, ns);
        }

        protected override MessageBuffer OnCreateBufferedCopy(int maxBufferSize)
        {
            return this.innerMessage.CreateBufferedCopy(maxBufferSize);
        }
      
        protected override IAsyncResult OnBeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, object state)
        {
            ImpersonateOnSerializingReplyMessageProperty impersonationProperty = null;
            IDisposable impersonationContext = null;
            IPrincipal originalPrincipal = null;
            bool isThreadPrincipalSet = false;

            if (!ImpersonateOnSerializingReplyMessageProperty.TryGet(this.innerMessage, out impersonationProperty))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnableToImpersonateWhileSerializingReponse)));
            }

            try
            {
                impersonationProperty.StartImpersonation(out impersonationContext, out originalPrincipal, out isThreadPrincipalSet);
                return this.innerMessage.BeginWriteBodyContents(writer, callback, state);
            }
            finally
            {
                try
                {
                    impersonationProperty.StopImpersonation(impersonationContext, originalPrincipal, isThreadPrincipalSet);
                }
#pragma warning suppress 56500 // covered by FxCOP
                catch
                {
                    string message = null;
                    try
                    {
                        message = SR.GetString(SR.SFxRevertImpersonationFailed0);
                    }
                    finally
                    {
                        DiagnosticUtility.FailFast(message);
                    }
                }
            }
            
           
        }

        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
        {
          this.ImpersonateCall( () => this.innerMessage.WriteBodyContents(writer));
        }

        protected override void OnEndWriteBodyContents(IAsyncResult result)
        {
            this.innerMessage.EndWriteBodyContents(result);
        }

        //Runs impersonated.
        protected override void OnBodyToString(XmlDictionaryWriter writer)
        {
            this.ImpersonateCall(() => this.innerMessage.BodyToString(writer));
        }

        void ImpersonateCall(Action callToImpersonate)
        {
            ImpersonateOnSerializingReplyMessageProperty impersonationProperty = null;
            IDisposable impersonationContext = null;
            IPrincipal originalPrincipal = null;
            bool isThreadPrincipalSet = false;

            if (!ImpersonateOnSerializingReplyMessageProperty.TryGet(this.innerMessage, out impersonationProperty))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnableToImpersonateWhileSerializingReponse)));
            }

            try
            {
                impersonationProperty.StartImpersonation(out impersonationContext, out originalPrincipal, out isThreadPrincipalSet);
                callToImpersonate();
            }
            finally
            {
                try
                {
                    impersonationProperty.StopImpersonation(impersonationContext, originalPrincipal, isThreadPrincipalSet);
                }
#pragma warning suppress 56500 // covered by FxCOP
                catch
                {
                    string message = null;
                    try
                    {
                        message = SR.GetString(SR.SFxRevertImpersonationFailed0);
                    }
                    finally
                    {
                        DiagnosticUtility.FailFast(message);
                    }
                }
            }
        }
    }
}