public static XmlDictionaryReader GetReaderAtDetailContents11(string detailName, string detailNamespace, XmlDictionaryReader headerReader)
{
XmlDictionaryString namespaceUri = DXD.Wsrm11Dictionary.Namespace;
headerReader.ReadFullStartElement(XD.WsrmFeb2005Dictionary.SequenceFault, namespaceUri);
headerReader.Skip();
headerReader.ReadFullStartElement(XD.Message12Dictionary.FaultDetail, namespaceUri);
if (((headerReader.NodeType == XmlNodeType.Element) && !(headerReader.NamespaceURI != detailNamespace)) && !(headerReader.LocalName != detailName))
{
return headerReader;
}
headerReader.Close();
return null;
}
public static void Deserialize(XmlDictionaryReader reader, out IList<DirectoryControl> controls, bool mustBePresent, bool fullChecks)
{
string str = null;
string str1 = null;
bool flag;
byte[] numArray = null;
controls = new List<DirectoryControl>();
if (mustBePresent || reader.IsStartElement("controls", "http://schemas.microsoft.com/2008/1/ActiveDirectory"))
{
reader.ReadFullStartElement("controls", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
while (reader.IsStartElement("control", "http://schemas.microsoft.com/2008/1/ActiveDirectory"))
{
string attribute = reader.GetAttribute("type");
string attribute1 = reader.GetAttribute("criticality");
reader.Read();
if (!reader.IsStartElement("controlValue", "http://schemas.microsoft.com/2008/1/ActiveDirectory"))
{
numArray = null;
}
else
{
string attribute2 = reader.GetAttribute("type", "http://www.w3.org/2001/XMLSchema-instance");
if (attribute2 != null)
{
XmlUtility.SplitPrefix(attribute2, out str, out str1);
numArray = reader.ReadElementContentAsBase64();
}
else
{
throw new ArgumentException();
}
}
if (!string.Equals("true", attribute1))
{
flag = false;
}
else
{
flag = true;
}
DirectoryControl directoryControl = new DirectoryControl(attribute, numArray, flag, true);
controls.Add(directoryControl);
reader.Read();
}
return;
}
else
{
return;
}
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace, XmlDictionaryReader headerReader)
{
XmlDictionaryReader reader;
try
{
WsrmFeb2005Dictionary dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString namespaceUri = dictionary.Namespace;
XmlBuffer buffer = null;
int sectionIndex = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(dictionary.SequenceFault, namespaceUri);
while (headerReader.Depth > depth)
{
if (((headerReader.NodeType == XmlNodeType.Element) && (headerReader.NamespaceURI == detailNamespace)) && (headerReader.LocalName == detailName))
{
if (buffer != null)
{
return null;
}
buffer = new XmlBuffer(0x7fffffff);
try
{
sectionIndex = buffer.SectionCount;
buffer.OpenSection(headerReader.Quotas).WriteNode(headerReader, false);
continue;
}
finally
{
buffer.CloseSection();
}
}
if (headerReader.Depth == depth)
{
break;
}
headerReader.Read();
}
if (buffer == null)
{
return null;
}
buffer.Close();
reader = buffer.GetReader(sectionIndex);
}
finally
{
headerReader.Close();
}
return reader;
}
private void ReadFrom(XmlDictionaryReader reader)
{
try
{
reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.RegisterResponse, this.coordinationXmlDictionaryStrings.Namespace);
this.CoordinatorProtocolService = EndpointAddress.ReadFrom(MessagingVersionHelper.AddressingVersion(this.protocolVersion), reader, this.coordinationXmlDictionaryStrings.CoordinatorProtocolService, this.coordinationXmlDictionaryStrings.Namespace);
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
}
catch (XmlException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception));
}
}
private void ReadFrom(XmlDictionaryReader reader)
{
try
{
reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.CreateCoordinationContextResponse, this.coordinationXmlDictionaryStrings.Namespace);
this.CoordinationContext = Microsoft.Transactions.Wsat.Messaging.CoordinationContext.ReadFrom(reader, this.coordinationXmlDictionaryStrings.CoordinationContext, this.coordinationXmlDictionaryStrings.Namespace, this.protocolVersion);
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
}
catch (XmlException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception));
}
catch (InvalidCoordinationContextException exception2)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception2));
}
}
public static EndpointAddress ReadFrom(AddressingVersion addressingVersion, XmlDictionaryReader reader)
{
if (reader == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
if (addressingVersion == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("addressingVersion");
reader.ReadFullStartElement();
EndpointAddress ea = ReadFromDriver(addressingVersion, reader);
reader.ReadEndElement();
return ea;
}
internal static EndpointAddress ReadFrom(XmlDictionaryReader reader, out AddressingVersion version)
{
if (reader == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
reader.ReadFullStartElement();
reader.MoveToContent();
if (reader.IsNamespaceUri(AddressingVersion.WSAddressing10.DictionaryNamespace))
{
version = AddressingVersion.WSAddressing10;
}
else if (reader.IsNamespaceUri(AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
version = AddressingVersion.WSAddressingAugust2004;
}
else if (reader.NodeType != XmlNodeType.Element)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
"reader", SR.GetString(SR.CannotDetectAddressingVersion));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
"reader", SR.GetString(SR.AddressingVersionNotSupported, reader.NamespaceURI));
}
EndpointAddress ea = ReadFromDriver(version, reader);
reader.ReadEndElement();
return ea;
}
private static OleTxTransactionHeader ReadFrom(XmlDictionaryReader reader)
{
System.ServiceModel.Transactions.WsatExtendedInformation wsatInfo = null;
if (reader.IsStartElement(XD.OleTxTransactionExternalDictionary.OleTxTransaction, XD.OleTxTransactionExternalDictionary.Namespace))
{
Uri uri;
string attribute = reader.GetAttribute(XD.CoordinationExternalDictionary.Identifier, CoordinationNamespace);
if (!string.IsNullOrEmpty(attribute) && !Uri.TryCreate(attribute, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidWsatExtendedInfo")));
}
string str2 = reader.GetAttribute(XD.CoordinationExternalDictionary.Expires, CoordinationNamespace);
uint timeout = 0;
if (!string.IsNullOrEmpty(str2))
{
try
{
timeout = XmlConvert.ToUInt32(str2);
}
catch (FormatException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidWsatExtendedInfo"), exception));
}
catch (OverflowException exception2)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidWsatExtendedInfo"), exception2));
}
}
if (!string.IsNullOrEmpty(attribute) || (timeout != 0))
{
wsatInfo = new System.ServiceModel.Transactions.WsatExtendedInformation(attribute, timeout);
}
}
reader.ReadFullStartElement(XD.OleTxTransactionExternalDictionary.OleTxTransaction, XD.OleTxTransactionExternalDictionary.Namespace);
byte[] propagationToken = ReadPropagationTokenElement(reader);
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return new OleTxTransactionHeader(propagationToken, wsatInfo);
}
public static byte[] ReadPropagationTokenElement(XmlDictionaryReader reader)
{
reader.ReadFullStartElement(XD.OleTxTransactionExternalDictionary.PropagationToken, XD.OleTxTransactionExternalDictionary.Namespace);
byte[] buffer = reader.ReadContentAsBase64();
if (buffer.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidPropagationToken")));
}
reader.ReadEndElement();
return buffer;
}
/// <summary>
/// Reads ClaimProperties from a XmlDictionaryReader and adds them to a Dictionary.
/// </summary>
/// <param name="dictionaryReader">XmlDictionaryReader positioned at the element dictionary.ClaimProperties </param>
/// <param name="dictionary">SessionDictionary to provide dictionary strings.</param>
/// <param name="properties">Dictionary to add properties to.</param>
/// <exception cref="ArgumentNullException">The input argument 'dictionaryReader', 'dictionary' or 'properties' is null.</exception>
/// <exception cref="SecurityTokenException">Is thrown if the 'name' of a property is null or an empty string.</exception>
/// <exception cref="SecurityTokenException">Is thrown if the 'value' of a property is null.</exception>
/// <remarks>Reads 'n' properties.</remarks>
void ReadClaimProperties(XmlDictionaryReader dictionaryReader, SessionDictionary dictionary, IDictionary<string, string> properties)
{
if (dictionaryReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionaryReader");
}
if (dictionary == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");
}
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("properties");
}
dictionaryReader.ReadStartElement();
// <Property>
while (dictionaryReader.IsStartElement(dictionary.ClaimProperty, dictionary.EmptyString))
{
// @Name, @Value
string name = dictionaryReader.GetAttribute(dictionary.ClaimPropertyName, dictionary.EmptyString);
string value = dictionaryReader.GetAttribute(dictionary.ClaimPropertyValue, dictionary.EmptyString);
if (string.IsNullOrEmpty(name))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4249)));
}
if (string.IsNullOrEmpty(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID4250)));
}
properties.Add(new KeyValuePair<string, string>(name, value));
dictionaryReader.ReadFullStartElement();
dictionaryReader.ReadEndElement();
}
dictionaryReader.ReadEndElement();
}
private static WsatRegistrationHeader ReadFrom(XmlDictionaryReader reader)
{
string str;
string str2;
reader.ReadFullStartElement(XD.DotNetAtomicTransactionExternalDictionary.RegisterInfo, XD.DotNetAtomicTransactionExternalDictionary.Namespace);
reader.MoveToStartElement(XD.DotNetAtomicTransactionExternalDictionary.LocalTransactionId, XD.DotNetAtomicTransactionExternalDictionary.Namespace);
Guid transactionId = reader.ReadElementContentAsGuid();
if (transactionId == Guid.Empty)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidRegistrationHeaderTransactionId")));
}
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.ContextId, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
Uri uri;
str = reader.ReadElementContentAsString().Trim();
if (((str.Length == 0) || (str.Length > 0x100)) || !Uri.TryCreate(str, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidRegistrationHeaderIdentifier")));
}
}
else
{
str = null;
}
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.TokenId, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
str2 = reader.ReadElementContentAsString().Trim();
if (str2.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidRegistrationHeaderTokenId")));
}
}
else
{
str2 = null;
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return new WsatRegistrationHeader(transactionId, str, str2);
}
public static EndpointAddress ReadFrom(AddressingVersion addressingVersion, XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
if (addressingVersion == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("addressingVersion");
}
reader.ReadFullStartElement(localName, ns);
EndpointAddress address = ReadFromDriver(addressingVersion, reader);
reader.ReadEndElement();
return address;
}
static OleTxTransactionHeader ReadFrom(XmlDictionaryReader reader)
{
WsatExtendedInformation info = null;
if (reader.IsStartElement(XD.OleTxTransactionExternalDictionary.OleTxTransaction,
XD.OleTxTransactionExternalDictionary.Namespace))
{
string identifier = reader.GetAttribute(XD.CoordinationExternalDictionary.Identifier, CoordinationNamespace);
if (!string.IsNullOrEmpty(identifier))
{
// Verify identifier is really a URI
Uri uri;
if (!Uri.TryCreate(identifier, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidWsatExtendedInfo)));
}
}
string attr = reader.GetAttribute(XD.CoordinationExternalDictionary.Expires, CoordinationNamespace);
uint timeout = 0;
if (!string.IsNullOrEmpty(attr))
{
try
{
timeout = XmlConvert.ToUInt32(attr);
}
catch (FormatException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidWsatExtendedInfo), e));
}
catch (OverflowException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidWsatExtendedInfo), e));
}
}
if (!string.IsNullOrEmpty(identifier) || timeout != 0)
{
info = new WsatExtendedInformation(identifier, timeout);
}
}
reader.ReadFullStartElement(XD.OleTxTransactionExternalDictionary.OleTxTransaction,
XD.OleTxTransactionExternalDictionary.Namespace);
byte[] propagationToken = ReadPropagationTokenElement(reader);
// Skip extensibility elements...
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return new OleTxTransactionHeader(propagationToken, info);
}
private void ReadFrom(XmlDictionaryReader reader)
{
try
{
reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.Register, this.coordinationXmlDictionaryStrings.Namespace);
reader.MoveToStartElement(this.coordinationXmlDictionaryStrings.Protocol, this.coordinationXmlDictionaryStrings.Namespace);
this.Protocol = WSAtomicTransactionStrings.WellKnownNameToProtocol(reader.ReadElementContentAsString().Trim(), this.protocolVersion);
if (this.Protocol == ControlProtocol.None)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody")));
}
this.ParticipantProtocolService = EndpointAddress.ReadFrom(MessagingVersionHelper.AddressingVersion(this.protocolVersion), reader, this.coordinationXmlDictionaryStrings.ParticipantProtocolService, this.coordinationXmlDictionaryStrings.Namespace);
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.Loopback, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
this.Loopback = reader.ReadElementContentAsGuid();
}
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
}
catch (XmlException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception));
}
}
private void ReadFrom(XmlDictionaryReader reader)
{
try
{
reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.CreateCoordinationContext, this.coordinationXmlDictionaryStrings.Namespace);
if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.Expires, this.coordinationXmlDictionaryStrings.Namespace))
{
int num = reader.ReadElementContentAsInt();
if (num < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody")));
}
this.expiration = (uint) num;
this.expiresPresent = true;
}
if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace))
{
this.CurrentContext = CoordinationContext.ReadFrom(reader, this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace, this.protocolVersion);
}
reader.MoveToStartElement(this.coordinationXmlDictionaryStrings.CoordinationType, this.coordinationXmlDictionaryStrings.Namespace);
if (reader.ReadElementContentAsString().Trim() != this.atomicTransactionStrings.Namespace)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody")));
}
if (!reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
goto Label_016B;
}
this.IsolationLevel = (System.Transactions.IsolationLevel) reader.ReadElementContentAsInt();
if (((this.IsolationLevel >= System.Transactions.IsolationLevel.Serializable) && (this.IsolationLevel <= System.Transactions.IsolationLevel.Unspecified)) && (this.IsolationLevel != System.Transactions.IsolationLevel.Snapshot))
{
goto Label_016B;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody")));
Label_0165:
reader.Skip();
Label_016B:
if (reader.IsStartElement())
{
goto Label_0165;
}
reader.ReadEndElement();
}
catch (XmlException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception));
}
catch (InvalidCoordinationContextException exception2)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception2));
}
}
/// <summary>
/// Reads a single ClaimsIdentity from a XmlDictionaryReader.
/// </summary>
/// <param name="dictionaryReader">XmlDictionaryReader positioned at dictionary.Identity.</param>
/// <param name="dictionary">SessionDictionary to provide dictionary strings.</param>
/// <exception cref="ArgumentNullException">The input argument 'dictionaryReader' or 'dictionary' is null.</exception>
/// <exception cref="SecurityTokenException">The dictionaryReader is not positioned a SessionDictionary.Identity.</exception>
/// <returns>ClaimsIdentity</returns>
ClaimsIdentity ReadIdentity(XmlDictionaryReader dictionaryReader, SessionDictionary dictionary)
{
if (dictionaryReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionaryReader");
}
if (dictionary == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");
}
dictionaryReader.MoveToContent();
ClaimsIdentity identity = null;
if (!dictionaryReader.IsStartElement(dictionary.Identity, dictionary.EmptyString))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityTokenException(SR.GetString(SR.ID3007, dictionaryReader.LocalName, dictionaryReader.NamespaceURI)));
}
// @NameClaimType
string nameClaimType = dictionaryReader.GetAttribute(dictionary.NameClaimType, dictionary.EmptyString);
// @RoleClaimType
string roleClaimType = dictionaryReader.GetAttribute(dictionary.RoleClaimType, dictionary.EmptyString);
// @WindowsLogonName (optional) => windows claims identity
string logonName = dictionaryReader.GetAttribute(dictionary.WindowsLogonName, dictionary.EmptyString);
string authenticationType = dictionaryReader.GetAttribute(dictionary.AuthenticationType, dictionary.EmptyString);
if (string.IsNullOrEmpty(logonName))
{
identity = new ClaimsIdentity(authenticationType, nameClaimType, roleClaimType);
}
else
{
// The WindowsIdentity(string, string) c'tor does not set the Auth type. Hence we use that c'tor to get a intPtr and
// call the other c'tor that actually sets the authType passed in.
// DevDiv 279196 tracks the issue and in WindowsIdentity c'tor. Its too late to fix it in 4.5 cycle as we are in Beta and would not be
// able to complete the analysis of the change for the current release. This should be investigated in 5.0
WindowsIdentity winId = new WindowsIdentity(GetUpn(logonName));
identity = new WindowsIdentity(winId.Token, authenticationType);
}
// @Label
identity.Label = dictionaryReader.GetAttribute(dictionary.Label, dictionary.EmptyString);
dictionaryReader.ReadFullStartElement();
// <ClaimCollection>
if (dictionaryReader.IsStartElement(dictionary.ClaimCollection, dictionary.EmptyString))
{
dictionaryReader.ReadStartElement();
Collection<Claim> claims = new Collection<Claim>();
ReadClaims(dictionaryReader, dictionary, claims);
identity.AddClaims(claims);
dictionaryReader.ReadEndElement();
}
// <Actor>
if (dictionaryReader.IsStartElement(dictionary.Actor, dictionary.EmptyString))
{
dictionaryReader.ReadStartElement();
identity.Actor = ReadIdentity(dictionaryReader, dictionary);
dictionaryReader.ReadEndElement();
}
if (dictionaryReader.IsStartElement(dictionary.BootstrapToken, dictionary.EmptyString))
{
dictionaryReader.ReadStartElement();
byte[] bytes = dictionaryReader.ReadContentAsBase64();
using (MemoryStream ms = new MemoryStream(bytes))
{
BinaryFormatter formatter = new BinaryFormatter();
identity.BootstrapContext = (BootstrapContext)formatter.Deserialize(ms);
}
dictionaryReader.ReadEndElement();
}
dictionaryReader.ReadEndElement(); // Identity
return identity;
}
/// <summary>
/// Reads the ClaimsIdentites from a XmlDictionaryReader and adds them to a ClaimIdentityColleciton.
/// </summary>
/// <param name="dictionaryReader">XmlDictionaryReader positioned at dictionary.Identities</param>
/// <param name="dictionary">SessionDictionary to provide dictionary strings.</param>
/// <param name="identities">A collection of <see cref="ClaimsIdentity"/> to populate.</param>
/// <exception cref="ArgumentNullException">The input argument 'dictionaryReader', 'dictionary' or 'identities' is null.</exception>
/// <remarks>Reads 'n' identies and adds them to identies.</remarks>
void ReadIdentities(XmlDictionaryReader dictionaryReader, SessionDictionary dictionary, Collection<ClaimsIdentity> identities)
{
if (dictionaryReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionaryReader");
}
if (dictionary == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");
}
if (identities == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("identities");
}
dictionaryReader.MoveToContent();
if (dictionaryReader.IsStartElement(dictionary.Identities, dictionary.EmptyString))
{
dictionaryReader.ReadFullStartElement();
while (dictionaryReader.IsStartElement(dictionary.Identity, dictionary.EmptyString))
{
identities.Add(ReadIdentity(dictionaryReader, dictionary));
}
dictionaryReader.ReadEndElement();
}
}
/// <summary>
/// Reads a ClaimsPrincipal from a XmlDictionaryReader.
/// </summary>
/// <param name="dictionaryReader">XmlDictionaryReader positioned at dictionary.ClaimsPrincipal.</param>
/// <param name="dictionary">SessionDictionary to provide dictionary strings.</param>
/// <exception cref="ArgumentNullException">The input argument 'dictionaryReader' or 'dictionary' is null.</exception>
/// <returns>ClaimsPrincipal</returns>
ClaimsPrincipal ReadPrincipal(XmlDictionaryReader dictionaryReader, SessionDictionary dictionary)
{
if (dictionaryReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionaryReader");
}
if (dictionary == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");
}
ClaimsPrincipal principal = null;
Collection<ClaimsIdentity> identities = new Collection<ClaimsIdentity>();
dictionaryReader.MoveToContent();
if (dictionaryReader.IsStartElement(dictionary.ClaimsPrincipal, dictionary.EmptyString))
{
dictionaryReader.ReadFullStartElement();
ReadIdentities(dictionaryReader, dictionary, identities);
dictionaryReader.ReadEndElement();
}
// If we find a WindowsIdentity in the identities we just read, we should be creating a WindowsPrincipal using it
WindowsIdentity wi = null;
foreach (ClaimsIdentity identity in identities)
{
wi = identity as WindowsIdentity;
if (wi != null)
{
principal = new WindowsPrincipal(wi);
break;
}
}
// If we did create a WindowsPrincipal we can remove the associated WindowsIdentity from the identities collection
// so that we dont add it twice in the subsequent step
if (principal != null)
{
identities.Remove(wi);
}
else if (identities.Count > 0)
{
// If we did not create a WindowsPrincipal, default to a ClaimsPrincipal
principal = new ClaimsPrincipal();
}
if (principal != null)
{
// Add the identities we just read to the principal
principal.AddIdentities(identities);
}
return principal;
}
static bool ReadContentsFrom10(XmlDictionaryReader reader, out Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection)
{
buffer = null;
extensionSection = -1;
metadataSection = -1;
// Cache address string
if (!reader.IsStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, SR.GetString(SR.UnexpectedElementExpectingElement, reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value)));
string address = reader.ReadElementContentAsString();
// Headers
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
else
{
headers = null;
}
// Metadata
if (reader.IsStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace))
{
reader.ReadFullStartElement(); // the wsa10:Metadata element is never stored in the buffer
buffer = new XmlBuffer(short.MaxValue);
metadataSection = 0;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement(DummyName, DummyNamespace);
while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF)
{
writer.WriteNode(reader, true);
}
writer.Flush();
buffer.CloseSection();
reader.ReadEndElement();
}
// Extensions
buffer = ReadExtensions(reader, AddressingVersion.WSAddressing10, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
// Process Address
if (address == Addressing10Strings.Anonymous)
{
uri = AddressingVersion.WSAddressing10.AnonymousUri;
if (headers == null && identity == null)
{
return true;
}
}
else if (address == Addressing10Strings.NoneAddress)
{
uri = AddressingVersion.WSAddressing10.NoneUri;
return false;
}
else
{
if (!Uri.TryCreate(address, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidUriValue, address, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value)));
}
}
return false;
}
private static bool ReadContentsFrom10(XmlDictionaryReader reader, out System.Uri uri, out AddressHeaderCollection headers, out EndpointIdentity identity, out XmlBuffer buffer, out int metadataSection, out int extensionSection)
{
buffer = null;
extensionSection = -1;
metadataSection = -1;
if (!reader.IsStartElement(XD.AddressingDictionary.Address, XD.Addressing10Dictionary.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateXmlException(reader, System.ServiceModel.SR.GetString("UnexpectedElementExpectingElement", new object[] { reader.LocalName, reader.NamespaceURI, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
string uriString = reader.ReadElementContentAsString();
if (reader.IsStartElement(XD.AddressingDictionary.ReferenceParameters, XD.Addressing10Dictionary.Namespace))
{
headers = AddressHeaderCollection.ReadServiceParameters(reader);
}
else
{
headers = null;
}
if (reader.IsStartElement(XD.Addressing10Dictionary.Metadata, XD.Addressing10Dictionary.Namespace))
{
reader.ReadFullStartElement();
buffer = new XmlBuffer(0x7fff);
metadataSection = 0;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
writer.WriteStartElement("Dummy", "http://Dummy");
while ((reader.NodeType != XmlNodeType.EndElement) && !reader.EOF)
{
writer.WriteNode(reader, true);
}
writer.Flush();
buffer.CloseSection();
reader.ReadEndElement();
}
buffer = ReadExtensions(reader, AddressingVersion.WSAddressing10, buffer, out identity, out extensionSection);
if (buffer != null)
{
buffer.Close();
}
if (uriString == "http://www.w3.org/2005/08/addressing/anonymous")
{
uri = AddressingVersion.WSAddressing10.AnonymousUri;
if ((headers == null) && (identity == null))
{
return true;
}
}
else
{
if (uriString == "http://www.w3.org/2005/08/addressing/none")
{
uri = AddressingVersion.WSAddressing10.NoneUri;
return false;
}
if (!System.Uri.TryCreate(uriString, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("InvalidUriValue", new object[] { uriString, XD.AddressingDictionary.Address.Value, XD.Addressing10Dictionary.Namespace.Value })));
}
}
return false;
}
private static void ReadFrom(CoordinationContext that, XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion)
{
try
{
Uri uri;
CoordinationXmlDictionaryStrings strings = CoordinationXmlDictionaryStrings.Version(protocolVersion);
AtomicTransactionStrings strings2 = AtomicTransactionStrings.Version(protocolVersion);
reader.ReadFullStartElement(localName, strings.Namespace);
reader.MoveToStartElement(strings.Identifier, strings.Namespace);
that.unknownIdentifierAttributes = ReadOtherAttributes(reader, strings.Namespace);
that.contextId = reader.ReadElementContentAsString().Trim();
if ((that.contextId.Length == 0) || (that.contextId.Length > 0x100))
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext")));
}
if (!Uri.TryCreate(that.contextId, UriKind.Absolute, out uri))
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext")));
}
if (reader.IsStartElement(strings.Expires, strings.Namespace))
{
that.unknownExpiresAttributes = ReadOtherAttributes(reader, strings.Namespace);
int num = reader.ReadElementContentAsInt();
if (num < 0)
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext")));
}
that.expiration = (uint) num;
that.expiresPresent = true;
}
reader.MoveToStartElement(strings.CoordinationType, strings.Namespace);
if (reader.ReadElementContentAsString().Trim() != strings2.Namespace)
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext")));
}
that.registrationRef = EndpointAddress.ReadFrom(MessagingVersionHelper.AddressingVersion(protocolVersion), reader, strings.RegistrationService, strings.Namespace);
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
that.isoLevel = (System.Transactions.IsolationLevel) reader.ReadElementContentAsInt();
if (((that.IsolationLevel < System.Transactions.IsolationLevel.Serializable) || (that.IsolationLevel > System.Transactions.IsolationLevel.Unspecified)) || (that.IsolationLevel == System.Transactions.IsolationLevel.Snapshot))
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext")));
}
}
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationFlags, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
that.isoFlags = (System.ServiceModel.Transactions.IsolationFlags) reader.ReadElementContentAsInt();
}
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.Description, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
that.description = reader.ReadElementContentAsString().Trim();
}
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.LocalTransactionId, XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
that.localTxId = reader.ReadElementContentAsGuid();
}
if (OleTxTransactionHeader.IsStartPropagationTokenElement(reader))
{
that.propToken = OleTxTransactionHeader.ReadPropagationTokenElement(reader);
}
if (reader.IsStartElement())
{
XmlDocument document = new XmlDocument();
that.unknownData = new List<System.Xml.XmlNode>(5);
while (reader.IsStartElement())
{
System.Xml.XmlNode item = document.ReadNode(reader);
that.unknownData.Add(item);
}
}
reader.ReadEndElement();
}
catch (XmlException exception)
{
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"), exception));
}
}
internal static EndpointAddress ReadFrom(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, out AddressingVersion version)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
reader.ReadFullStartElement(localName, ns);
reader.MoveToContent();
if (reader.IsNamespaceUri(AddressingVersion.WSAddressing10.DictionaryNamespace))
{
version = AddressingVersion.WSAddressing10;
}
else if (reader.IsNamespaceUri(AddressingVersion.WSAddressingAugust2004.DictionaryNamespace))
{
version = AddressingVersion.WSAddressingAugust2004;
}
else
{
if (reader.NodeType != XmlNodeType.Element)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("reader", System.ServiceModel.SR.GetString("CannotDetectAddressingVersion"));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("reader", System.ServiceModel.SR.GetString("AddressingVersionNotSupported", new object[] { reader.NamespaceURI }));
}
EndpointAddress address = ReadFromDriver(version, reader);
reader.ReadEndElement();
return address;
}
public override SecurityToken ReadTokenCore(XmlDictionaryReader reader, SecurityTokenResolver tokenResolver)
{
UniqueId contextId = null;
byte[] encodedCookie = null;
UniqueId generation = null;
bool isCookieMode = false;
Fx.Assert(reader.NodeType == XmlNodeType.Element, "");
// check if there is an id
string id = reader.GetAttribute(XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace);
SecurityContextSecurityToken sct = null;
// There needs to be at least a contextId in here.
reader.ReadFullStartElement();
reader.MoveToStartElement(parent.SerializerDictionary.Identifier, parent.SerializerDictionary.Namespace);
contextId = reader.ReadElementContentAsUniqueId();
if (CanReadGeneration(reader))
{
generation = ReadGeneration(reader);
}
if (reader.IsStartElement(parent.SerializerDictionary.Cookie, XD.DotNetSecurityDictionary.Namespace))
{
isCookieMode = true;
ISecurityContextSecurityTokenCache sctCache;
sct = TryResolveSecurityContextToken(contextId, generation, id, tokenResolver, out sctCache);
if (sct == null)
{
encodedCookie = reader.ReadElementContentAsBase64();
if (encodedCookie != null)
{
sct = cookieSerializer.CreateSecurityContextFromCookie(encodedCookie, contextId, generation, id, reader.Quotas);
if (sctCache != null)
{
sctCache.AddContext(sct);
}
}
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
if (contextId == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.GetString(SR.NoSecurityContextIdentifier)));
}
if (sct == null && !isCookieMode)
{
ISecurityContextSecurityTokenCache sctCache;
sct = TryResolveSecurityContextToken(contextId, generation, id, tokenResolver, out sctCache);
}
if (sct == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new SecurityContextTokenValidationException(SR.GetString(SR.SecurityContextNotRegistered, contextId, generation)));
}
return sct;
}
public static byte[] ReadPropagationTokenElement(XmlDictionaryReader reader)
{
reader.ReadFullStartElement(XD.OleTxTransactionExternalDictionary.PropagationToken,
XD.OleTxTransactionExternalDictionary.Namespace);
byte[] propagationToken = reader.ReadContentAsBase64();
if (propagationToken.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidPropagationToken)));
}
reader.ReadEndElement();
return propagationToken;
}
/// <summary>
/// Reads Claims from a XmlDictionaryReader and adds them to a ClaimCollection.
/// </summary>
/// <param name="dictionaryReader">XmlDictionaryReader positioned at dictionary.Claim.</param>
/// <param name="dictionary">SessionDictionary to provide dictionary strings.</param>
/// <param name="claims">ClaimCollection to add the claims to.</param>
/// <exception cref="ArgumentNullException">The input argument 'dictionaryReader', 'dictionary' or 'claims' is null.</exception>
/// <remarks>Reads 'n' claims and adds them to claims.</remarks>
void ReadClaims(XmlDictionaryReader dictionaryReader, SessionDictionary dictionary, Collection<Claim> claims)
{
if (dictionaryReader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionaryReader");
}
if (dictionary == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dictionary");
}
if (claims == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("claims");
}
while (dictionaryReader.IsStartElement(dictionary.Claim, dictionary.EmptyString))
{
// @Issuer (optional), @OriginalIssuer (optional), @Type, @Value, @ValueType
Claim claim = new Claim(dictionaryReader.GetAttribute(dictionary.Type, dictionary.EmptyString),
dictionaryReader.GetAttribute(dictionary.Value, dictionary.EmptyString),
dictionaryReader.GetAttribute(dictionary.ValueType, dictionary.EmptyString),
dictionaryReader.GetAttribute(dictionary.Issuer, dictionary.EmptyString),
dictionaryReader.GetAttribute(dictionary.OriginalIssuer, dictionary.EmptyString));
dictionaryReader.ReadFullStartElement();
// <Properties> (optional)
if (dictionaryReader.IsStartElement(dictionary.ClaimProperties, dictionary.EmptyString))
{
ReadClaimProperties(dictionaryReader, dictionary, claim.Properties);
}
dictionaryReader.ReadEndElement();
claims.Add(claim);
}
}
public static Int64 ReadElementContentAsInt64(XmlDictionaryReader reader)
{
reader.ReadFullStartElement();
Int64 i = reader.ReadContentAsLong();
reader.ReadEndElement();
return i;
}
/// <summary>
/// Reads an <see cref="EndpointReference"/> from xml dictionary reader. The addressing version is defaulted to
/// <see cref="WSAddressing10Constants.Elements.Address"/>.
/// </summary>
/// <param name="reader">The xml dictionary reader.</param>
/// <returns>An <see cref="EndpointReference"/> instance.</returns>
public static EndpointReference ReadFrom(XmlDictionaryReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
reader.ReadFullStartElement();
reader.MoveToContent();
if (reader.IsNamespaceUri(WSAddressing10Constants.NamespaceUri) || reader.IsNamespaceUri(WSAddressing200408Constants.NamespaceUri))
{
if (reader.IsStartElement(WSAddressing10Constants.Elements.Address, WSAddressing10Constants.NamespaceUri) ||
reader.IsStartElement(WSAddressing10Constants.Elements.Address, WSAddressing200408Constants.NamespaceUri))
{
EndpointReference er = new EndpointReference(reader.ReadElementContentAsString());
while ( reader.IsStartElement() )
{
bool emptyElement = reader.IsEmptyElement;
XmlReader subtreeReader = reader.ReadSubtree();
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.Load( subtreeReader );
er._details.Add( doc.DocumentElement );
if ( !emptyElement )
{
reader.ReadEndElement();
}
}
reader.ReadEndElement();
return er;
}
}
return null;
}
public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace,
XmlDictionaryReader headerReader)
{
try
{
WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary;
XmlDictionaryString wsrmNs = wsrmFeb2005Dictionary.Namespace;
XmlBuffer buffer = null;
int index = 0;
int depth = headerReader.Depth;
headerReader.ReadFullStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
while (headerReader.Depth > depth)
{
if ((headerReader.NodeType == XmlNodeType.Element)
&& (headerReader.NamespaceURI == detailNamespace)
&& (headerReader.LocalName == detailName))
{
if (buffer != null)
{
return null;
}
buffer = new XmlBuffer(int.MaxValue);
try
{
index = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(headerReader.Quotas);
// WriteNode moves the reader to the next sibling.
writer.WriteNode(headerReader, false);
}
finally
{
buffer.CloseSection();
}
}
else
{
if (headerReader.Depth == depth)
break;
headerReader.Read();
}
}
// Ensure at least one detail is found;
if (buffer == null)
{
return null;
}
// Close causes a state change. It moves the buffer from Created to Reading.
buffer.Close();
XmlDictionaryReader detailReader = buffer.GetReader(index);
return detailReader;
}
finally
{
headerReader.Close();
}
}
static WsatRegistrationHeader ReadFrom(XmlDictionaryReader reader)
{
reader.ReadFullStartElement(XD.DotNetAtomicTransactionExternalDictionary.RegisterInfo,
XD.DotNetAtomicTransactionExternalDictionary.Namespace);
reader.MoveToStartElement(XD.DotNetAtomicTransactionExternalDictionary.LocalTransactionId,
XD.DotNetAtomicTransactionExternalDictionary.Namespace);
// TransactionId
Guid transactionId = reader.ReadElementContentAsGuid();
if (transactionId == Guid.Empty)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(SR.GetString(SR.InvalidRegistrationHeaderTransactionId)));
}
// ContextId
string contextId;
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.ContextId,
XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
Uri uri;
contextId = reader.ReadElementContentAsString().Trim();
if (contextId.Length == 0 ||
contextId.Length > CoordinationContext.MaxIdentifierLength ||
!Uri.TryCreate(contextId, UriKind.Absolute, out uri))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(SR.GetString(SR.InvalidRegistrationHeaderIdentifier)));
}
}
else
{
contextId = null;
}
// TokenId
string tokenId;
if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.TokenId,
XD.DotNetAtomicTransactionExternalDictionary.Namespace))
{
tokenId = reader.ReadElementContentAsString().Trim();
if (tokenId.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(SR.GetString(SR.InvalidRegistrationHeaderTokenId)));
}
}
else
{
tokenId = null;
}
// Skip unknown elements
while (reader.IsStartElement())
{
reader.Skip();
}
reader.ReadEndElement();
return new WsatRegistrationHeader(transactionId, contextId, tokenId);
}
