public static ReceivedFault CreateFault11(XmlDictionaryReader reader, int maxBufferSize)
{
string str;
string str2;
reader.ReadStartElement(XD.MessageDictionary.Fault, XD.Message11Dictionary.Namespace);
reader.ReadStartElement(XD.Message11Dictionary.FaultCode, XD.Message11Dictionary.FaultNamespace);
XmlUtil.ReadContentAsQName(reader, out str2, out str);
FaultCode code = new FaultCode(str2, str);
reader.ReadEndElement();
string xmlLang = reader.XmlLang;
reader.MoveToContent();
FaultReasonText translation = new FaultReasonText(reader.ReadElementContentAsString(XD.Message11Dictionary.FaultString.Value, XD.Message11Dictionary.FaultNamespace.Value), xmlLang);
string actor = "";
if (reader.IsStartElement(XD.Message11Dictionary.FaultActor, XD.Message11Dictionary.FaultNamespace))
{
actor = reader.ReadElementContentAsString();
}
XmlBuffer detail = null;
if (reader.IsStartElement(XD.Message11Dictionary.FaultDetail, XD.Message11Dictionary.FaultNamespace))
{
detail = new XmlBuffer(maxBufferSize);
detail.OpenSection(reader.Quotas).WriteNode(reader, false);
detail.CloseSection();
detail.Close();
}
reader.ReadEndElement();
return(new ReceivedFault(code, new FaultReason(translation), actor, actor, detail, EnvelopeVersion.Soap11));
}
public RawFaultException(XmlDictionaryReader reader) :
base("The service returned a fault - see FaultMessage, FaultStackTrace, and FaultType.")
{
reader.ReadToFollowing("Message");
m_faultMessage = reader.ReadElementContentAsString();
m_stackTrace = reader.ReadElementContentAsString("StackTrace", reader.NamespaceURI);
m_type = Type.GetType(reader.ReadElementContentAsString("Type", reader.NamespaceURI));
}
static PollingDuplexSession ReadHeaderValue(XmlDictionaryReader reader)
{
string str = null;
string str2 = null;
if (reader.IsStartElement("Duplex", "http://schemas.microsoft.com/2008/04/netduplex"))
{
reader.ReadStartElement();
reader.MoveToContent();
while (reader.IsStartElement())
{
if (reader.IsStartElement("SessionId", "http://schemas.microsoft.com/2008/04/netduplex"))
{
if (!string.IsNullOrEmpty(str2))
{
throw new InvalidOperationException("Multiple sessionId elements in a duplex header.");
}
str2 = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(str2))
{
throw new InvalidOperationException("Invalid sessionId element content in a duplex header.");
}
}
else
{
if (reader.IsStartElement("Address", "http://schemas.microsoft.com/2008/04/netduplex"))
{
if (!string.IsNullOrEmpty(str))
{
throw new InvalidOperationException("Multiple address elements in a duplex header.");
}
str = reader.ReadElementContentAsString();
if (string.IsNullOrEmpty(str))
{
throw new InvalidOperationException("Invalid address element in a duplex header.");
}
continue;
}
if (reader.IsStartElement("CloseSession", "http://schemas.microsoft.com/2008/04/netduplex"))
{
reader.Skip();
continue;
}
reader.Skip();
}
}
reader.ReadEndElement();
}
if (str == null)
{
throw new InvalidOperationException("Missing address in a duplex header.");
}
if (str2 == null)
{
throw new InvalidOperationException("Missing sessionId in a duplex header.");
}
return(new PollingDuplexSession(str, str2));
}
private static ReceivedFault CreateFault12Driver(XmlDictionaryReader reader, int maxBufferSize, EnvelopeVersion version)
{
reader.ReadStartElement(XD.MessageDictionary.Fault, version.DictionaryNamespace);
reader.ReadStartElement(XD.Message12Dictionary.FaultCode, version.DictionaryNamespace);
FaultCode code = ReadFaultCode12Driver(reader, version);
reader.ReadEndElement();
List <FaultReasonText> translations = new List <FaultReasonText>();
if (reader.IsEmptyElement)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FormatException(SR.AtLeastOneFaultReasonMustBeSpecified));
}
else
{
reader.ReadStartElement(XD.Message12Dictionary.FaultReason, version.DictionaryNamespace);
while (reader.IsStartElement(XD.Message12Dictionary.FaultText, version.DictionaryNamespace))
{
translations.Add(ReadTranslation12(reader));
}
reader.ReadEndElement();
}
string actor = "";
string node = "";
if (reader.IsStartElement(XD.Message12Dictionary.FaultNode, version.DictionaryNamespace))
{
node = reader.ReadElementContentAsString();
}
if (reader.IsStartElement(XD.Message12Dictionary.FaultRole, version.DictionaryNamespace))
{
actor = reader.ReadElementContentAsString();
}
XmlBuffer detail = null;
if (reader.IsStartElement(XD.Message12Dictionary.FaultDetail, version.DictionaryNamespace))
{
detail = new XmlBuffer(maxBufferSize);
XmlDictionaryWriter writer = detail.OpenSection(reader.Quotas);
writer.WriteNode(reader, false);
detail.CloseSection();
detail.Close();
}
reader.ReadEndElement();
FaultReason reason = new FaultReason(translations);
return(new ReceivedFault(code, reason, actor, node, detail, version));
}
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 static FaultReasonText ReadTranslation12(XmlDictionaryReader reader)
{
string xmlLang = XmlUtil.GetXmlLangAttribute(reader);
string text = reader.ReadElementContentAsString();
return(new FaultReasonText(text, xmlLang));
}
public virtual void ReadXml(XmlDictionaryReader reader,
SamlSerializer samlSerializer,
SecurityTokenSerializer keyInfoTokenSerializer,
SecurityTokenResolver outOfBandTokenResolver)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (samlSerializer == null)
{
throw new ArgumentNullException("samlSerializer");
}
reader.ReadStartElement("Subject", SamlConstants.Namespace);
NameFormat = reader.GetAttribute("Format");
NameQualifier = reader.GetAttribute("NameQualifier");
Name = reader.ReadElementContentAsString("NameIdentifier", SamlConstants.Namespace);
reader.ReadEndElement();
if (Name == null || Name.Length == 0)
{
throw new SecurityTokenException("non-zero length string must be exist for Name.");
}
}
public static void ReadElementContentAsStringDataExceedsMaxBytesPerReadQuota()
{
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas();
quotas.MaxBytesPerRead = 4096;
int contentLength = 8176;
string testString = new string('a', contentLength);
string returnedString;
XmlDictionary dict = new XmlDictionary();
XmlDictionaryString dictEntry = dict.Add("Value");
using (var ms = new MemoryStream())
{
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateBinaryWriter(ms, dict);
xmlWriter.WriteElementString(dictEntry, XmlDictionaryString.Empty, testString);
xmlWriter.Flush();
ms.Position = 0;
XmlDictionaryReader xmlReader = XmlDictionaryReader.CreateBinaryReader(ms, dict, quotas);
xmlReader.Read();
returnedString = xmlReader.ReadElementContentAsString();
}
Assert.Equal(testString, returnedString);
}
public static PullNotificationHeader ParseHeader(OperationContext context)
{
try
{
int headerIndex = context.IncomingMessageHeaders.FindHeader(NOTIFICATION_HEADER_NAME, PULL_NOTIFICATION_NAMESPACE);
if (headerIndex != -1)
{
XmlDictionaryReader reader = context.IncomingMessageHeaders.GetReaderAtHeader(headerIndex);
if (reader.IsStartElement(NOTIFICATION_HEADER_NAME, PULL_NOTIFICATION_NAMESPACE))
{
reader.ReadStartElement();
reader.MoveToContent();
if (reader.IsStartElement(ADDRESS_ELEMENT_NAME, PULL_NOTIFICATION_NAMESPACE))
{
string address = reader.ReadElementContentAsString();
return(new PullNotificationHeader(address));
}
}
}
return(null);
}
catch (Exception excp)
{
logger.Error("Exception PullNotificationHeader ParseHeader. " + excp.Message);
throw;
}
}
public override ArraySegment <byte> WriteMessage(Message message,
int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
String bodyContent = null;
lastMessage = message.Headers.Action;
XmlDictionaryReader reader = message.GetReaderAtBodyContents();
while (reader.Read())
{
if (reader.Name == "request")
{
bodyContent = reader.ReadElementContentAsString();
break;
}
}
reader.Close();
byte[] messageBytes = System.Text.Encoding.UTF8.GetBytes(bodyContent);
int totalLength = messageBytes.Length + messageOffset;
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0,
totalBytes, messageOffset, messageBytes.Length);
ArraySegment <byte> buffer =
new ArraySegment <byte>(
totalBytes, messageOffset, messageBytes.Length);
return(buffer);
}
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));
}
/// <summary>
/// Reads the X.509 Security token referenced by the XmlReader.
/// </summary>
/// <param name="reader">XmlReader pointing to a X.509 Security token.</param>
/// <returns>An instance of <see cref="X509SecurityToken"/>.</returns>
/// <exception cref="ArgumentNullException">The parameter 'reader' is null.</exception>
/// <exception cref="XmlException">XmlReader is not pointing to an valid X509SecurityToken as
/// defined in WS-Security X.509 Token Profile. Or the encodingType specified is other than Base64
/// or HexBinary.</exception>
public override SecurityToken ReadToken(XmlReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
XmlDictionaryReader dicReader = XmlDictionaryReader.CreateDictionaryReader(reader);
if (!dicReader.IsStartElement(WSSecurity10Constants.Elements.BinarySecurityToken, WSSecurity10Constants.Namespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(
SR.GetString(
SR.ID4065,
WSSecurity10Constants.Elements.BinarySecurityToken,
WSSecurity10Constants.Namespace,
dicReader.LocalName,
dicReader.NamespaceURI)));
}
string valueTypeUri = dicReader.GetAttribute(WSSecurity10Constants.Attributes.ValueType, null);
if (!StringComparer.Ordinal.Equals(valueTypeUri, WSSecurity10Constants.X509TokenType))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(
SR.GetString(
SR.ID4066,
WSSecurity10Constants.Elements.BinarySecurityToken,
WSSecurity10Constants.Namespace,
WSSecurity10Constants.Attributes.ValueType,
WSSecurity10Constants.X509TokenType,
valueTypeUri)));
}
string wsuId = dicReader.GetAttribute(WSSecurityUtilityConstants.Attributes.Id, WSSecurityUtilityConstants.Namespace);
string encoding = dicReader.GetAttribute(WSSecurity10Constants.Attributes.EncodingType, null);
byte[] binaryData;
if (encoding == null || StringComparer.Ordinal.Equals(encoding, WSSecurity10Constants.Base64EncodingType))
{
binaryData = dicReader.ReadElementContentAsBase64();
}
else if (StringComparer.Ordinal.Equals(encoding, WSSecurity10Constants.HexBinaryEncodingType))
{
binaryData = SoapHexBinary.Parse(dicReader.ReadElementContentAsString()).Value;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.ID4068)));
}
return(String.IsNullOrEmpty(wsuId) ?
new X509SecurityToken(new X509Certificate2(binaryData)) :
new X509SecurityToken(new X509Certificate2(binaryData), wsuId));
}
static MessageFault CreateFault12(Message message, int maxBufferSize)
{
FaultCode fc = null;
FaultReason fr = null;
string node = null;
XmlDictionaryReader r = message.GetReaderAtBodyContents();
r.ReadStartElement("Fault", message.Version.Envelope.Namespace);
for (r.MoveToContent(); r.NodeType != XmlNodeType.EndElement; r.MoveToContent())
{
if (r.NamespaceURI != message.Version.Envelope.Namespace)
{
r.Skip();
continue;
}
switch (r.LocalName)
{
case "Code":
fc = ReadFaultCode12(r, message.Version.Envelope.Namespace);
break;
case "Reason":
fr = ReadFaultReason12(r, message.Version.Envelope.Namespace);
break;
case "Node":
node = r.ReadElementContentAsString();
break;
case "Role":
r.Skip(); // no corresponding member to store.
break;
case "Detail":
if (!r.IsEmptyElement)
{
return(new XmlReaderDetailMessageFault(message, r, fc, fr, null, node));
}
r.Read();
break;
default:
throw new XmlException(String.Format("Unexpected node {0} name {1}", r.NodeType, r.Name));
}
}
if (fr == null)
{
throw new XmlException("Reason is missing in the Fault message");
}
r.ReadEndElement();
return(new SimpleMessageFault(fc, fr, false, null, null, null, node));
}
public static string ReadHeaderValue(XmlDictionaryReader reader, AddressingVersion addressingVersion)
{
string s = reader.ReadElementContentAsString();
if ((s.Length <= 0) || ((s[0] > ' ') && (s[s.Length - 1] > ' ')))
{
return(s);
}
return(XmlUtil.Trim(s));
}
static MessageFault CreateFault11(Message message, int maxBufferSize)
{
FaultCode fc = null;
FaultReason fr = null;
string actor = null;
XmlDictionaryReader r = message.GetReaderAtBodyContents();
r.ReadStartElement("Fault", message.Version.Envelope.Namespace);
r.MoveToContent();
while (r.NodeType != XmlNodeType.EndElement)
{
switch (r.LocalName)
{
case "faultcode":
fc = ReadFaultCode11(r);
break;
case "faultstring":
fr = new FaultReason(r.ReadElementContentAsString());
break;
case "faultactor":
actor = r.ReadElementContentAsString();
break;
case "detail":
return(new XmlReaderDetailMessageFault(message, r, fc, fr, actor, null));
default:
throw new XmlException(String.Format("Unexpected node {0} name {1}", r.NodeType, r.Name));
}
r.MoveToContent();
}
r.ReadEndElement();
if (fr == null)
{
throw new XmlException("Reason is missing in the Fault message");
}
return(new SimpleMessageFault(fc, fr, false, null, null, actor, null));
}
object ReadMessagePart(MessagePartDescription part, XmlDictionaryReader r)
{
if (part.Type == typeof(Stream))
{
// FIXME: it seems TransferMode.Streamed* has different serialization than .Buffered. Need to differentiate serialization somewhere (not limited to here).
return(new MemoryStream(Convert.FromBase64String(r.ReadElementContentAsString(part.Name, part.Namespace))));
}
else
{
return(GetSerializer(part).ReadObject(r));
}
}
protected override int ReadArray(XmlDictionaryReader reader, string localName, string namespaceUri, DateTime[] array, int offset, int count)
{
XmlJsonReader.CheckArray(array, offset, count);
int num = 0;
while ((num < count) && reader.IsStartElement("item", string.Empty))
{
array[offset + num] = JsonReaderDelegator.ParseJsonDate(reader.ReadElementContentAsString());
num++;
}
return(num);
}
public static string ReadHeaderValue(XmlDictionaryReader reader, AddressingVersion addressingVersion)
{
Fx.Assert(reader.IsStartElement(XD.AddressingDictionary.Action, addressingVersion.DictionaryNamespace), "");
string act = reader.ReadElementContentAsString();
if (act.Length > 0 && (act[0] <= 32 || act[act.Length - 1] <= 32))
{
act = XmlUtil.Trim(act);
}
return(act);
}
void ReadTokenContent()
{
switch (reader.NamespaceURI)
{
case Constants.WstNamespace:
switch (reader.LocalName)
{
case "RequestType":
req.RequestType = reader.ReadElementContentAsString();
return;
case "Entropy":
ReadEntropy();
return;
case "KeySize":
req.KeySize = reader.ReadElementContentAsInt();
return;
case "KeyType":
req.KeyType = reader.ReadElementContentAsString();
return;
case "ComputedKeyAlgorithm":
req.ComputedKeyAlgorithm = reader.ReadElementContentAsString();
return;
}
break;
case Constants.WspNamespace:
switch (reader.LocalName)
{
case "AppliesTo":
ReadAppliesTo();
return;
}
break;
}
throw new XmlException(String.Format("Unexpected RequestSecurityToken content element. Name is {0} and namespace URI is {1}{2}", reader.Name, reader.NamespaceURI, LineInfo()));
}
public static ReceivedFault CreateFault11(XmlDictionaryReader reader, int maxBufferSize)
{
reader.ReadStartElement(XD.MessageDictionary.Fault, XD.Message11Dictionary.Namespace);
string ns;
string name;
reader.ReadStartElement(XD.Message11Dictionary.FaultCode, XD.Message11Dictionary.FaultNamespace);
XmlUtil.ReadContentAsQName(reader, out name, out ns);
FaultCode code = new FaultCode(name, ns);
reader.ReadEndElement();
string xmlLang = reader.XmlLang;
reader.MoveToContent(); // Don't do IsStartElement. FaultString is required, so let the reader throw.
string text = reader.ReadElementContentAsString(XD.Message11Dictionary.FaultString.Value, XD.Message11Dictionary.FaultNamespace.Value);
FaultReasonText translation = new FaultReasonText(text, xmlLang);
string actor = "";
if (reader.IsStartElement(XD.Message11Dictionary.FaultActor, XD.Message11Dictionary.FaultNamespace))
{
actor = reader.ReadElementContentAsString();
}
XmlBuffer detail = null;
if (reader.IsStartElement(XD.Message11Dictionary.FaultDetail, XD.Message11Dictionary.FaultNamespace))
{
detail = new XmlBuffer(maxBufferSize);
XmlDictionaryWriter writer = detail.OpenSection(reader.Quotas);
writer.WriteNode(reader, false);
detail.CloseSection();
detail.Close();
}
reader.ReadEndElement();
FaultReason reason = new FaultReason(translation);
return(new ReceivedFault(code, reason, actor, actor, detail, EnvelopeVersion.Soap11));
}
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>
/// Parses the "X509IssuerSerial" element and generates a corresponding <see cref="X509IssuerSerialKeyIdentifierClause"/> instance.
/// </summary>
/// <param name="dictionaryReader">The <see cref="XmlDictionaryReader"/> currently positioning on the "X509IssuerSerial" element. </param>
/// <returns>An instance of <see cref="X509IssuerSerialKeyIdentifierClause"/> created from the "X509IssuerSerial" element.</returns>
private static SecurityKeyIdentifierClause CreateIssuerSerialKeyIdentifierClause(XmlDictionaryReader dictionaryReader)
{
dictionaryReader.ReadStartElement(XmlSignatureConstants.Elements.X509IssuerSerial, XmlSignatureConstants.Namespace);
if (!dictionaryReader.IsStartElement(XmlSignatureConstants.Elements.X509IssuerName, XmlSignatureConstants.Namespace))
{
throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3032, dictionaryReader.LocalName, dictionaryReader.NamespaceURI, XmlSignatureConstants.Elements.X509IssuerName, XmlSignatureConstants.Namespace));
}
string issuerName = dictionaryReader.ReadElementContentAsString(XmlSignatureConstants.Elements.X509IssuerName, XmlSignatureConstants.Namespace);
if (!dictionaryReader.IsStartElement(XmlSignatureConstants.Elements.X509SerialNumber, XmlSignatureConstants.Namespace))
{
throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3032, dictionaryReader.LocalName, dictionaryReader.NamespaceURI, XmlSignatureConstants.Elements.X509SerialNumber, XmlSignatureConstants.Namespace));
}
string serialNumber = dictionaryReader.ReadElementContentAsString(XmlSignatureConstants.Elements.X509SerialNumber, XmlSignatureConstants.Namespace);
dictionaryReader.ReadEndElement(); // Reade the ending </X509IssuerSerial> element.
return(new X509IssuerSerialKeyIdentifierClause(issuerName, serialNumber));
}
public static MakeConnectionMessageInfo Create(XmlDictionaryReader reader)
{
MakeConnectionMessageInfo makeConnectionInfo = new MakeConnectionMessageInfo();
if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.Name, MakeConnectionConstants.Namespace))
{
reader.ReadStartElement();
reader.MoveToContent();
while (reader.IsStartElement())
{
if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.AddressElement, MakeConnectionConstants.Namespace))
{
if (!string.IsNullOrEmpty(makeConnectionInfo.Address))
{
makeConnectionInfo.MultipleAddressHeaders = true;
reader.Skip();
}
else
{
makeConnectionInfo.Address = reader.ReadElementContentAsString();
}
}
else if (reader.IsStartElement(MakeConnectionConstants.MakeConnectionMessage.IdentifierElement, MakeConnectionConstants.Namespace))
{
if (makeConnectionInfo.Identifier != null)
{
makeConnectionInfo.MultipleIdentifierHeaders = true;
reader.Skip();
}
else
{
makeConnectionInfo.Identifier = reader.ReadElementContentAsUniqueId();
}
}
else
{
if (string.IsNullOrEmpty(makeConnectionInfo.UnknownSelection))
{
makeConnectionInfo.UnknownSelection = reader.LocalName;
}
reader.Skip();
}
}
reader.ReadEndElement();
}
return(makeConnectionInfo);
}
public static Uri ReadHeaderValue(XmlDictionaryReader reader, AddressingVersion version, UriCache uriCache)
{
string uriString = reader.ReadElementContentAsString();
if (uriString == version.Anonymous)
{
return(version.AnonymousUri);
}
if (uriCache == null)
{
return(new Uri(uriString));
}
return(uriCache.CreateUri(uriString));
}
static MessageFault CreateFault11(Message message, int maxBufferSize)
{
FaultCode fc = null;
FaultReason fr = null;
object details = null;
XmlDictionaryReader r = message.GetReaderAtBodyContents();
r.ReadStartElement("Fault", message.Version.Envelope.Namespace);
r.MoveToContent();
while (r.NodeType != XmlNodeType.EndElement)
{
switch (r.LocalName)
{
case "faultcode":
fc = ReadFaultCode11(r);
break;
case "faultstring":
fr = new FaultReason(r.ReadElementContentAsString());
break;
case "detail":
//BUGBUG: Handle children of type other than ExceptionDetail, in order to comply with
// FaultContractAttribute.
r.ReadStartElement();
r.MoveToContent();
details = new DataContractSerializer(typeof(ExceptionDetail)).ReadObject(r);
break;
case "faultactor":
default:
throw new NotImplementedException();
}
r.MoveToContent();
}
r.ReadEndElement();
if (fr == null)
{
throw new XmlException("Reason is missing in the Fault message");
}
if (details == null)
{
return(CreateFault(fc, fr));
}
return(CreateFault(fc, fr, details));
}
public virtual void ReadXml(XmlDictionaryReader reader,
SamlSerializer samlSerializer,
SecurityTokenSerializer keyInfoSerializer,
SecurityTokenResolver resolver)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (samlSerializer == null)
{
throw new ArgumentNullException("samlSerializer");
}
references.Clear();
assertions.Clear();
reader.ReadStartElement("Evidence", SamlConstants.Namespace);
for (reader.MoveToContent();
reader.NodeType == XmlNodeType.Element;
reader.MoveToContent())
{
if (reader.NamespaceURI != SamlConstants.Namespace)
{
throw new SecurityTokenException(String.Format("Invalid SAML Evidence element: element '{0}' in namespace '{1}' is unexpected.", reader.LocalName, reader.NamespaceURI));
}
switch (reader.LocalName)
{
case "Assertion":
SamlAssertion a = new SamlAssertion();
a.ReadXml(reader, samlSerializer, keyInfoSerializer, resolver);
assertions.Add(a);
break;
case "AssertionIDReference":
references.Add(reader.ReadElementContentAsString());
break;
default:
throw new SecurityTokenException(String.Format("Invalid SAML Evidence element: SAML element '{0}' is unexpected.", reader.LocalName));
}
}
reader.ReadEndElement();
if (references.Count == 0 && assertions.Count == 0)
{
throw new SecurityTokenException("At least either one of AssertionIDReference or Assertion must exist in SAML Evidence.");
}
}
