linux-packaging-mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/HttpTransportManager.cs

//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
    using System.Collections.Generic;
    using System.ServiceModel;
    using System.ServiceModel.Diagnostics;
    using System.Runtime;
    using System.ServiceModel.Diagnostics.Application;
    using System.Runtime.Diagnostics;

    abstract class HttpTransportManager : TransportManager, ITransportManagerRegistration
    {
        volatile Dictionary<string, UriPrefixTable<HttpChannelListener>> addressTables;
        readonly HostNameComparisonMode hostNameComparisonMode;
        readonly Uri listenUri;
        readonly string realm;

        internal HttpTransportManager()
        {
            this.addressTables = new Dictionary<string, UriPrefixTable<HttpChannelListener>>();
        }

        internal HttpTransportManager(Uri listenUri, HostNameComparisonMode hostNameComparisonMode)
            : this()
        {
            this.hostNameComparisonMode = hostNameComparisonMode;
            this.listenUri = listenUri;
        }

        internal HttpTransportManager(Uri listenUri, HostNameComparisonMode hostNameComparisonMode, string realm)
            : this(listenUri, hostNameComparisonMode)
        {
            this.realm = realm;
        }

        internal string Realm
        {
            get
            {
                return this.realm;
            }
        }

        public HostNameComparisonMode HostNameComparisonMode
        {
            get
            {
                return this.hostNameComparisonMode;
            }
        }

        // are we hosted in Asp.Net? Default is false.
        internal bool IsHosted
        {
            get;
            set;
        }

        internal override string Scheme
        {
            get
            {
                return Uri.UriSchemeHttp;
            }
        }

        internal virtual UriPrefixTable<ITransportManagerRegistration> TransportManagerTable
        {
            get
            {
                return HttpChannelListener.StaticTransportManagerTable;
            }
        }

        public Uri ListenUri
        {
            get
            {
                return this.listenUri;
            }
        }

        protected void Fault(Exception exception)
        {
            lock (ThisLock)
            {
                foreach (KeyValuePair<string, UriPrefixTable<HttpChannelListener>> pair in this.addressTables)
                {
                    this.Fault(pair.Value, exception);
                }
            }
        }

        internal virtual bool IsCompatible(HttpChannelListener listener)
        {
            return (
                (this.hostNameComparisonMode == listener.HostNameComparisonMode) &&
                (this.realm == listener.Realm)
                );
        }

        internal override void OnClose(TimeSpan timeout)
        {
            Cleanup();
        }

        internal override void OnAbort()
        {
            Cleanup();
            base.OnAbort();
        }

        void Cleanup()
        {
            this.TransportManagerTable.UnregisterUri(this.ListenUri, this.HostNameComparisonMode);
        }

        protected void StartReceiveBytesActivity(ServiceModelActivity activity, Uri requestUri)
        {
            Fx.Assert(DiagnosticUtility.ShouldUseActivity, "should only call this if we're using SM Activities");
            ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityReceiveBytes, requestUri.ToString()), ActivityType.ReceiveBytes);
        }

        protected void TraceMessageReceived(EventTraceActivity eventTraceActivity, Uri listenUri)
        {
            if (TD.HttpMessageReceiveStartIsEnabled())
            {                
                TD.HttpMessageReceiveStart(eventTraceActivity);
            }
        }

        protected bool TryLookupUri(Uri requestUri, string requestMethod,
                    HostNameComparisonMode hostNameComparisonMode, bool isWebSocketRequest, out HttpChannelListener listener)
        {
            listener = null;

            if (isWebSocketRequest)
            {
                Fx.Assert(StringComparer.OrdinalIgnoreCase.Compare(requestMethod, "GET") == 0, "The requestMethod must be GET in WebSocket case.");
                requestMethod = WebSocketTransportSettings.WebSocketMethod;
            }
            
            if (requestMethod == null)
            {
                requestMethod = string.Empty;
            }

            UriPrefixTable<HttpChannelListener> addressTable;
            Dictionary<string, UriPrefixTable<HttpChannelListener>> localAddressTables = addressTables;

            // check for a method match if necessary
            HttpChannelListener methodListener = null;
            if (requestMethod.Length > 0)
            {
                if (localAddressTables.TryGetValue(requestMethod, out addressTable))
                {
                    if (addressTable.TryLookupUri(requestUri, hostNameComparisonMode, out methodListener)
                        && string.Compare(requestUri.AbsolutePath, methodListener.Uri.AbsolutePath, StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        methodListener = null;
                    }
                }
            }
            // and also check the wildcard bucket 
            if (localAddressTables.TryGetValue(string.Empty, out addressTable)
                && addressTable.TryLookupUri(requestUri, hostNameComparisonMode, out listener))
            {
                if (methodListener != null && methodListener.Uri.AbsoluteUri.Length >= listener.Uri.AbsoluteUri.Length)
                {
                    listener = methodListener;
                }
            }
            else
            {
                listener = methodListener;
            }

            return (listener != null);
        }



        internal override void Register(TransportChannelListener channelListener)
        {
            string method = ((HttpChannelListener)channelListener).Method;

            UriPrefixTable<HttpChannelListener> addressTable;
            if (!addressTables.TryGetValue(method, out addressTable))
            {
                lock (ThisLock)
                {
                    if (!addressTables.TryGetValue(method, out addressTable))
                    {
                        Dictionary<string, UriPrefixTable<HttpChannelListener>> newAddressTables =
                            new Dictionary<string, UriPrefixTable<HttpChannelListener>>(addressTables);

                        addressTable = new UriPrefixTable<HttpChannelListener>();
                        newAddressTables[method] = addressTable;

                        addressTables = newAddressTables;
                    }
                }
            }

            addressTable.RegisterUri(channelListener.Uri,
                channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal,
                (HttpChannelListener)channelListener);
        }

        IList<TransportManager> ITransportManagerRegistration.Select(TransportChannelListener channelListener)
        {
            IList<TransportManager> result = null;
            if (this.IsCompatible((HttpChannelListener)channelListener))
            {
                result = new List<TransportManager>();
                result.Add(this);
            }
            return result;
        }

        internal override void Unregister(TransportChannelListener channelListener)
        {
            UriPrefixTable<HttpChannelListener> addressTable;
            if (!addressTables.TryGetValue(((HttpChannelListener)channelListener).Method, out addressTable))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(
                     SR.ListenerFactoryNotRegistered, channelListener.Uri)));
            }

            HostNameComparisonMode registeredMode = channelListener.InheritBaseAddressSettings ? hostNameComparisonMode : channelListener.HostNameComparisonModeInternal;

            EnsureRegistered(addressTable, (HttpChannelListener)channelListener, registeredMode);
            addressTable.UnregisterUri(channelListener.Uri, registeredMode);
        }

        protected class ActivityHolder : IDisposable
        {
            internal HttpRequestContext context;
            internal ServiceModelActivity activity;

            public ActivityHolder(ServiceModelActivity activity, HttpRequestContext requestContext)
            {
                Fx.Assert(requestContext != null, "requestContext cannot be null.");
                this.activity = activity;
                this.context = requestContext;
            }

            public void Dispose()
            {
                if (this.activity != null)
                {
                    this.activity.Dispose();
                }
            }
        }
    }
}