linux-packaging-mono/mcs/class/referencesource/System.ServiceModel.Routing/System/ServiceModel/Routing/MessageRpc.cs

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

namespace System.ServiceModel.Routing
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Globalization;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Activation;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Description;
    using System.ServiceModel.Security;
    using System.Transactions;
    using SR2 = System.ServiceModel.Routing.SR;
    using System.Security.Principal;
    using System.Runtime.Diagnostics;
    using System.ServiceModel.Diagnostics;

    // This class wraps a Message, MessageBuffer (if requested), and the OperationContext
    // The message is not buffered if nobody calls MessageRpc.CreateBuffer.  If the message
    // is buffered, then we hang on to the buffer so it can be reused and Clone the message
    // which became invalid when we buffered this message.
    class MessageRpc
    {
        const int ERROR_BAD_IMPERSONATION_LEVEL = 1346;

        Message originalMessage;
        Message clonedMessage;
        MessageBuffer messageBuffer;
        string uniqueID;
        Transaction transaction;
        ReceiveContext receiveContext;
        IList<SendOperation> operations;
        WindowsIdentity windowsIdentity;
        EventTraceActivity eventTraceActivity;

        public MessageRpc(Message message, OperationContext operationContext, bool impersonationRequired)
        {
            Fx.Assert(message != null, "message cannot be null");
            Fx.Assert(operationContext != null, "operationContext cannot be null");

            this.originalMessage = message;
            this.OperationContext = operationContext;

            if (Fx.Trace.IsEtwProviderEnabled)
            {
                this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
            }

            //passing in true causes this to return null if the thread is not impersonating.
            this.windowsIdentity = WindowsIdentity.GetCurrent(true);
            if (impersonationRequired && !AspNetEnvironment.Current.AspNetCompatibilityEnabled)
            {
                if (this.windowsIdentity == null || this.windowsIdentity.ImpersonationLevel != TokenImpersonationLevel.Impersonation)
                {
                    //Temporarily revert impersonation to process token to throw an exception
                    IDisposable autoRevert = null;
                    try
                    {
                        try { }
                        finally
                        {
                            autoRevert = WindowsIdentity.Impersonate(IntPtr.Zero);
                        }

                        Win32Exception errorDetail = new Win32Exception(ERROR_BAD_IMPERSONATION_LEVEL);
                        throw FxTrace.Exception.AsError(new SecurityNegotiationException(errorDetail.Message));
                    }
                    finally
                    {
                        if (autoRevert != null)
                        {
                            autoRevert.Dispose();
                        }
                    }
                }
            }

            ReceiveContext.TryGet(message, out this.receiveContext);

            this.transaction = Transaction.Current;
            if (this.transaction == null)
            {
                this.transaction = TransactionMessageProperty.TryGetTransaction(message);
            }
        }

        internal bool Impersonating
        {
            get { return this.windowsIdentity != null; }
        }

        internal EventTraceActivity EventTraceActivity
        {
            get
            {
                return this.eventTraceActivity;
            }
        }

        public OperationContext OperationContext
        {
            get;
            private set;
        }

        public string UniqueID
        {
            get
            {
                if (this.uniqueID == null)
                {
                    if (this.Message.Version != MessageVersion.None &&
                        this.Message.Headers.MessageId != null)
                    {
                        this.uniqueID = this.originalMessage.Headers.MessageId.ToString();
                    }
                    else
                    {
                        this.uniqueID = this.GetHashCode().ToString(CultureInfo.InvariantCulture);
                    }
                }
                return this.uniqueID;
            }
        }

        public Message Message
        {
            get
            {
                // If we've created a MessageBuffer then the originalMessage has already been consumed
                if (this.messageBuffer != null)
                {
                    Fx.Assert(this.clonedMessage != null, "Need to set clonedMessage if we buffered the message");
                    return this.clonedMessage;
                }
                else
                {
                    // Haven't buffered, can use the original.
                    return this.originalMessage;
                }
            }
        }

        public ReceiveContext ReceiveContext
        {
            get { return this.receiveContext; }
        }

        public IList<SendOperation> Operations
        {
            get { return this.operations; }
        }

        public Transaction Transaction
        {
            get { return this.transaction; }
        }

        public MessageBuffer CreateBuffer()
        {
            if (this.messageBuffer == null)
            {
                this.messageBuffer = this.originalMessage.CreateBufferedCopy(int.MaxValue);
                this.clonedMessage = this.messageBuffer.CreateMessage();
            }
            return this.messageBuffer;
        }

        public IDisposable PrepareCall()
        {
            return new CallState(this);
        }

        public void RouteToSingleEndpoint<TContract>(RoutingConfiguration routingConfig)
        {
            IEnumerable<ServiceEndpoint> result;
            if (routingConfig.RouteOnHeadersOnly)
            {
                if (TD.RoutingServiceFilterTableMatchStartIsEnabled()) { TD.RoutingServiceFilterTableMatchStart(this.eventTraceActivity); }
                routingConfig.InternalFilterTable.GetMatchingValue(this.Message, out result);
                if (TD.RoutingServiceFilterTableMatchStopIsEnabled()) { TD.RoutingServiceFilterTableMatchStop(this.eventTraceActivity); }
            }
            else
            {
                MessageBuffer buffer = this.CreateBuffer();

                if (TD.RoutingServiceFilterTableMatchStartIsEnabled()) { TD.RoutingServiceFilterTableMatchStart(this.eventTraceActivity); }
                routingConfig.InternalFilterTable.GetMatchingValue(buffer, out result);
                if (TD.RoutingServiceFilterTableMatchStopIsEnabled()) { TD.RoutingServiceFilterTableMatchStop(this.eventTraceActivity); }
            }

            if (result == null)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.NoFilterMatched));
            }

            if (TD.RoutingServiceMessageRoutedToEndpointsIsEnabled())
            {
                TD.RoutingServiceMessageRoutedToEndpoints(this.eventTraceActivity, this.UniqueID, "1");
            }

            this.operations = new List<SendOperation>(1);
            this.operations.Add(new SendOperation(result, typeof(TContract), this.OperationContext));
        }

        public void RouteToEndpoints<TContract>(RoutingConfiguration routingConfig)
        {
            List<IEnumerable<ServiceEndpoint>> endpointLists = new List<IEnumerable<ServiceEndpoint>>();
            if (routingConfig.RouteOnHeadersOnly)
            {
                if (TD.RoutingServiceFilterTableMatchStartIsEnabled()) { TD.RoutingServiceFilterTableMatchStart(this.eventTraceActivity); }
                routingConfig.InternalFilterTable.GetMatchingValues(this.Message, endpointLists);
                if (TD.RoutingServiceFilterTableMatchStopIsEnabled()) { TD.RoutingServiceFilterTableMatchStop(this.eventTraceActivity); }
            }
            else
            {
                MessageBuffer messageBuffer = this.CreateBuffer();

                if (TD.RoutingServiceFilterTableMatchStartIsEnabled()) { TD.RoutingServiceFilterTableMatchStart(this.eventTraceActivity); }
                routingConfig.InternalFilterTable.GetMatchingValues(messageBuffer, endpointLists);
                if (TD.RoutingServiceFilterTableMatchStopIsEnabled()) { TD.RoutingServiceFilterTableMatchStop(this.eventTraceActivity); }
            }
            
            if (TD.RoutingServiceMessageRoutedToEndpointsIsEnabled())
            {
                TD.RoutingServiceMessageRoutedToEndpoints(this.eventTraceActivity, this.UniqueID, endpointLists.Count.ToString(TD.Culture));
            }
            if (endpointLists.Count == 0)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.NoFilterMatched));
            }
            this.operations = new List<SendOperation>(endpointLists.Count);
            foreach (IEnumerable<ServiceEndpoint> endpointList in endpointLists)
            {
                this.operations.Add(new SendOperation(endpointList, typeof(TContract), this.OperationContext));
            }
        }

        class CallState : IDisposable
        {
            OperationContextScope nullContextScope;
            WindowsImpersonationContext impersonation;

            public CallState (MessageRpc messageRpc)
            {
                this.nullContextScope = new OperationContextScope((OperationContext)null);

                if (messageRpc.windowsIdentity != null)
                {
                    this.impersonation = messageRpc.windowsIdentity.Impersonate();
                }
            }

            void IDisposable.Dispose()
            {
                if (this.impersonation != null)
                {
                    this.impersonation.Dispose();
                }
                this.nullContextScope.Dispose();
            }
        }
    }
}