Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Security/IssuedTokensHeader.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

254 lines
9.8 KiB
C#

//------------------------------------------------------------
// 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;
}
}
}