Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Security/IssuedTokensHeader.cs

@@ -0,0 +1,253 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Security
+{
+    using System.Collections.Generic;
+    using System.ServiceModel.Channels;
+    using System.Collections.ObjectModel;
+    using System.Globalization;
+    using System.ServiceModel;
+    using System.Xml;
+    using System.IdentityModel.Selectors;
+    using System.ServiceModel.Diagnostics;
+
+    sealed class IssuedTokensHeader : MessageHeader
+    {
+        ReadOnlyCollection<RequestSecurityTokenResponse> tokenIssuances;
+        SecurityStandardsManager standardsManager;
+        string actor;
+        bool mustUnderstand;
+        bool relay;
+        bool isRefParam;
+
+        public IssuedTokensHeader(RequestSecurityTokenResponse tokenIssuance, MessageSecurityVersion version, SecurityTokenSerializer tokenSerializer)
+            : this(tokenIssuance, new SecurityStandardsManager(version, tokenSerializer))
+        {
+        }
+
+
+        public IssuedTokensHeader(RequestSecurityTokenResponse tokenIssuance, SecurityStandardsManager standardsManager)
+            : base()
+        {
+            if (tokenIssuance == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenIssuance");
+            }
+            Collection<RequestSecurityTokenResponse> coll = new Collection<RequestSecurityTokenResponse>();
+            coll.Add(tokenIssuance);
+            Initialize(coll, standardsManager);
+        }
+
+        public IssuedTokensHeader(IEnumerable<RequestSecurityTokenResponse> tokenIssuances, SecurityStandardsManager standardsManager)
+            : base()
+        {
+            if (tokenIssuances == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenIssuances");
+            }
+            int index = 0;
+            Collection<RequestSecurityTokenResponse> coll = new Collection<RequestSecurityTokenResponse>();
+            foreach (RequestSecurityTokenResponse rstr in tokenIssuances)
+            {
+                if (rstr == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(String.Format(CultureInfo.InvariantCulture, "tokenIssuances[{0}]", index));
+                }
+                coll.Add(rstr);
+                ++index;
+            }
+            Initialize(coll, standardsManager);
+        }
+
+        void Initialize(Collection<RequestSecurityTokenResponse> coll, SecurityStandardsManager standardsManager)
+        {
+            if (standardsManager == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager"));
+            }
+            this.standardsManager = standardsManager;
+            this.tokenIssuances = new ReadOnlyCollection<RequestSecurityTokenResponse>(coll);
+            this.actor = base.Actor;
+            this.mustUnderstand = base.MustUnderstand;
+            this.relay = base.Relay;
+        }
+
+
+        public IssuedTokensHeader(XmlReader xmlReader, MessageVersion version, SecurityStandardsManager standardsManager)
+            : base()
+        {
+            if (xmlReader == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader");
+            }
+            if (standardsManager == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager"));
+            }
+            this.standardsManager = standardsManager;
+            XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xmlReader);
+            MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam);
+            reader.ReadStartElement(this.Name, this.Namespace);
+            Collection<RequestSecurityTokenResponse> coll = new Collection<RequestSecurityTokenResponse>();
+            if (this.standardsManager.TrustDriver.IsAtRequestSecurityTokenResponseCollection(reader))
+            {
+                RequestSecurityTokenResponseCollection rstrColl = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponseCollection(reader);
+                foreach (RequestSecurityTokenResponse rstr in rstrColl.RstrCollection)
+                {
+                    coll.Add(rstr);
+                }
+            }
+            else
+            {
+                RequestSecurityTokenResponse rstr = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponse(reader);
+                coll.Add(rstr);
+            }
+            this.tokenIssuances = new ReadOnlyCollection<RequestSecurityTokenResponse>(coll);
+            reader.ReadEndElement();
+        }
+
+
+        public ReadOnlyCollection<RequestSecurityTokenResponse> TokenIssuances
+        {
+            get
+            {
+                return this.tokenIssuances;
+            }
+        }
+
+        public override string Actor
+        {
+            get 
+            {
+                return this.actor;
+            }
+        }
+
+        public override bool IsReferenceParameter
+        {
+            get
+            {
+                return this.isRefParam;
+            }
+        }
+
+        public override bool MustUnderstand
+        {
+            get 
+            { 
+                return this.mustUnderstand; 
+            }
+
+        }
+
+        public override bool Relay
+        {
+            get 
+            { 
+                return this.relay; 
+            }
+        }
+
+
+        public override string Name
+        {
+            get
+            {
+                return this.standardsManager.TrustDriver.IssuedTokensHeaderName;
+            }
+        }
+
+        public override string Namespace
+        {
+            get
+            {
+                return this.standardsManager.TrustDriver.IssuedTokensHeaderNamespace;
+            }
+        }
+
+        protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
+        {
+            if (this.tokenIssuances.Count == 1)
+            {
+                this.standardsManager.TrustDriver.WriteRequestSecurityTokenResponse(this.tokenIssuances[0], writer);
+            }
+            else
+            {
+                RequestSecurityTokenResponseCollection rstrCollection = new RequestSecurityTokenResponseCollection(this.tokenIssuances, this.standardsManager);
+                rstrCollection.WriteTo(writer);
+            }
+        }
+
+        internal static Collection<RequestSecurityTokenResponse> ExtractIssuances(Message message, MessageSecurityVersion version, WSSecurityTokenSerializer tokenSerializer, string[] actors, XmlQualifiedName expectedAppliesToQName)
+        {
+            return ExtractIssuances(message, new SecurityStandardsManager(version, tokenSerializer), actors, expectedAppliesToQName);
+        }
+
+        // if expectedAppliesToQName is null all issuances matching the actors are returned.
+        internal static Collection<RequestSecurityTokenResponse> ExtractIssuances(Message message, SecurityStandardsManager standardsManager, string[] actors, XmlQualifiedName expectedAppliesToQName)
+        {
+            if (message == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
+            }
+            if (standardsManager == null)
+            {
+                standardsManager = SecurityStandardsManager.DefaultInstance;
+            }
+            if (actors == null)
+            {
+                throw TraceUtility.ThrowHelperArgumentNull("actors", message);
+            }
+            Collection<RequestSecurityTokenResponse> issuances = new Collection<RequestSecurityTokenResponse>();
+            for (int i = 0; i < message.Headers.Count; ++i)
+            {
+                if (message.Headers[i].Name == standardsManager.TrustDriver.IssuedTokensHeaderName && message.Headers[i].Namespace == standardsManager.TrustDriver.IssuedTokensHeaderNamespace)
+                {
+                    bool isValidActor = false;
+                    for (int j = 0; j < actors.Length; ++j)
+                    {
+                        if (actors[j] == message.Headers[i].Actor)
+                        {
+                            isValidActor = true;
+                            break;
+                        }
+                    }
+                    if (!isValidActor)
+                    {
+                        continue;
+                    }
+                    IssuedTokensHeader issuedTokensHeader = new IssuedTokensHeader(message.Headers.GetReaderAtHeader(i), message.Version, standardsManager);
+                    for (int k = 0; k < issuedTokensHeader.TokenIssuances.Count; ++k)
+                    {
+                        bool isMatch;
+                        if (expectedAppliesToQName != null)
+                        {
+                            string issuanceAppliesToName;
+                            string issuanceAppliesToNs;
+                            issuedTokensHeader.TokenIssuances[k].GetAppliesToQName(out issuanceAppliesToName, out issuanceAppliesToNs);
+                            if (issuanceAppliesToName == expectedAppliesToQName.Name && issuanceAppliesToNs == expectedAppliesToQName.Namespace)
+                            {
+                                isMatch = true;
+                            }
+                            else
+                            {
+                                isMatch = false;
+                            }
+                        }
+                        else
+                        {
+                            isMatch = true;
+                        }
+                        if (isMatch)
+                        {
+                            issuances.Add(issuedTokensHeader.TokenIssuances[k]);
+                        }
+                    }
+                }
+            }
+            return issuances;
+        }
+    }
+}