linux-packaging-mono/external/referencesource/System/net/System/Net/_SpnDictionary.cs

/*++
Copyright (c) Microsoft Corporation

Module Name:

    _SpnDictionary.cs

Abstract:
    This internal class implements a static mutlithreaded dictionary for user-registered SPNs.
    An SPN is mapped based on a Uri prefix that contains scheme, host and port.


Author:

    Alexei Vopilov    15-Nov-2003

Revision History:

--*/

namespace System.Net {
    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Security.Permissions;

    internal class SpnDictionary : StringDictionary {

        //
        //A Hashtable can support one writer and multiple readers concurrently
        //

        // Maps Uri keys to SpnToken values.  The SpnTokens should not be exposed publicly.
        private Hashtable m_SyncTable = Hashtable.Synchronized(new Hashtable());
        private ValueCollection m_ValuesWrapper;

        //
        //
        internal SpnDictionary():base() {
        }
        //
        //
        //
        public override int Count {
            get {
                ExceptionHelper.WebPermissionUnrestricted.Demand();
                return m_SyncTable.Count;
            }
        }
        //
        // We are thread safe
        //
        public override bool IsSynchronized {
            get {
                return true;
            }
        }
        //
        // Internal lookup, bypasses security checks
        //
        internal SpnToken InternalGet(string canonicalKey)
        {
            int lastLength = 0;
            string key = null;

            // This lock is required to avoid getting InvalidOperationException
            // because the collection was modified during enumeration. By design 
            // a Synchronized Hashtable throws if modifications occur while an 
            // enumeration is in progress. Manually locking the Hashtable to 
            // prevent modification during enumeration is the best solution. 
            // Catching the exception and retrying could potentially never
            // succeed in the face of significant updates.
            lock (m_SyncTable.SyncRoot) {
                foreach (object o in m_SyncTable.Keys){
                    string s = (string) o;
                    if(s != null && s.Length > lastLength){
                        if(String.Compare(s,0,canonicalKey,0,s.Length,StringComparison.OrdinalIgnoreCase) == 0){
                             lastLength = s.Length;
                             key = s;
                        }
                    }
                }  
            }
            return (key != null) ? (SpnToken)m_SyncTable[key] : null;
        }

        internal void InternalSet(string canonicalKey, SpnToken spnToken)
        {
            m_SyncTable[canonicalKey] = spnToken;
        }
        //
        // Public lookup method
        //
        public override string this[string key] {
            get {
                key = GetCanonicalKey(key);
                SpnToken token = InternalGet(key);
                return (token == null ? null : token.Spn);
            }
            set {
                key = GetCanonicalKey(key);
                // Value may be null
                InternalSet(key, new SpnToken(value));
            }
        }
        //
        public override ICollection Keys {
            get {
                ExceptionHelper.WebPermissionUnrestricted.Demand();
                return m_SyncTable.Keys;
            }
        }
        //
        public override object SyncRoot {
            [HostProtection(Synchronization=true)]
            get {
                ExceptionHelper.WebPermissionUnrestricted.Demand();
                return m_SyncTable;
            }
        }
        //
        public override ICollection Values {
            get {
                ExceptionHelper.WebPermissionUnrestricted.Demand();
                if (m_ValuesWrapper == null)
                {
                    m_ValuesWrapper = new ValueCollection(this);
                }
                return m_ValuesWrapper;
            }
        }
        //
        public override void Add(string key, string value) {
            key = GetCanonicalKey(key);
            m_SyncTable.Add(key, new SpnToken(value));
        }
        //
        public override void Clear() {
            ExceptionHelper.WebPermissionUnrestricted.Demand();
            m_SyncTable.Clear();
        }
        //
        public override bool ContainsKey(string key) {
            key = GetCanonicalKey(key);
            return m_SyncTable.ContainsKey(key);
        }
        //
        public override bool ContainsValue(string value) {
            ExceptionHelper.WebPermissionUnrestricted.Demand();
            foreach (SpnToken spnToken in m_SyncTable.Values)
            {
                if (spnToken.Spn == value)
                    return true;
            }
            return false;
        }

        // We have to unwrap the SpnKey and just expose the Spn
        public override void CopyTo(Array array, int index) {
            ExceptionHelper.WebPermissionUnrestricted.Demand();
            CheckCopyToArguments(array, index, Count);

            int offset = 0;
            foreach (object entry in this)
            {
                array.SetValue(entry, offset + index);
                offset++;
            }
        }
        //
        public override IEnumerator GetEnumerator() {
            ExceptionHelper.WebPermissionUnrestricted.Demand();

            foreach (string key in m_SyncTable.Keys)
            {
                // We must unwrap the SpnToken and not expose it publicly
                SpnToken spnToken = (SpnToken)m_SyncTable[key];
                yield return new DictionaryEntry(key, spnToken.Spn);
            }
        }
        //
        public override void Remove(string key) {
            key = GetCanonicalKey(key);
            m_SyncTable.Remove(key);
        }

        //
        // Private stuff: We want to serialize on updates on one thread
        //
        private static string GetCanonicalKey(string key)
        {
            if( key == null ) {
                throw new ArgumentNullException("key");
            }
            try {
                Uri uri = new Uri(key);
                key = uri.GetParts(UriComponents.Scheme | UriComponents.Host | UriComponents.Port | UriComponents.Path, UriFormat.SafeUnescaped);
                new WebPermission(NetworkAccess.Connect, new Uri(key)).Demand();
            }
            catch(UriFormatException e) {
                throw new ArgumentException(SR.GetString(SR.net_mustbeuri, "key"), "key", e);
            }
            return key;
        }

        private static void CheckCopyToArguments(Array array, int index, int count)
        {
            // Coppied from HashTable.CopyTo
            if (array == null)
            {
                throw new ArgumentNullException("array");
            }
            if (array.Rank != 1)
            {
                throw new ArgumentException(SR.GetString(SR.Arg_RankMultiDimNotSupported));
            }
            if (index < 0)
            {
                throw new ArgumentOutOfRangeException("index", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNum));
            }
            if ((array.Length - index) < count)
            {
                throw new ArgumentException(SR.GetString(SR.Arg_ArrayPlusOffTooSmall));
            }
        }

        // Wrap HashTable.Values so we can unwrap the SpnTokens
        private class ValueCollection : ICollection
        {
            private SpnDictionary spnDictionary;

            internal ValueCollection(SpnDictionary spnDictionary)
            {
                this.spnDictionary = spnDictionary;
            }

            public void CopyTo(Array array, int index)
            {
                CheckCopyToArguments(array, index, Count);
                
                int offset = 0;
                foreach (object entry in this)
                {
                    array.SetValue(entry, offset + index);
                    offset++;
                }
            }

            public int Count
            {
                get { return spnDictionary.m_SyncTable.Values.Count; }
            }

            public bool IsSynchronized
            {
                get { return true; }
            }

            public object SyncRoot
            {
                get { return spnDictionary.m_SyncTable.SyncRoot; }
            }

            public IEnumerator GetEnumerator()
            {
                foreach (SpnToken spnToken in spnDictionary.m_SyncTable.Values)
                {
                    yield return (spnToken != null ? spnToken.Spn : null);
                }
            }
        }
    }

    internal class SpnToken
    {
        private readonly string spn;
        private bool isTrusted;

        // Assume the spn is trusted unless a specific reason is found not to trust it.
        internal bool IsTrusted
        {
            get { return isTrusted; }
            set { isTrusted = false; }
        }

        internal string Spn
        {
            get { return spn; }
        }

        internal SpnToken(string spn)
            : this(spn, true)
        { }

        internal SpnToken(string spn, bool trusted)
        {
            this.spn = spn;
            this.isTrusted = trusted;
        }
    }
}