mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
486 lines
18 KiB
C#
486 lines
18 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Security
|
|
{
|
|
using System.IO;
|
|
using System.ServiceModel.Channels;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
static class XmlHelper
|
|
{
|
|
internal static void AddNamespaceDeclaration(XmlDictionaryWriter writer, string prefix, XmlDictionaryString ns)
|
|
{
|
|
string p = writer.LookupPrefix(ns.Value);
|
|
if (p == null || p != prefix)
|
|
{
|
|
writer.WriteXmlnsAttribute(prefix, ns);
|
|
}
|
|
}
|
|
|
|
internal static string EnsureNamespaceDefined(XmlDictionaryWriter writer, XmlDictionaryString ns, string defaultPrefix)
|
|
{
|
|
string p = writer.LookupPrefix(ns.Value);
|
|
if (p == null)
|
|
{
|
|
writer.WriteXmlnsAttribute(defaultPrefix, ns);
|
|
p = defaultPrefix;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
internal static XmlQualifiedName GetAttributeValueAsQName(XmlReader reader, string attributeName)
|
|
{
|
|
string qname = reader.GetAttribute(attributeName);
|
|
if (qname == null)
|
|
{
|
|
return null;
|
|
}
|
|
return GetValueAsQName(reader, qname);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enforces that parent has exactly 1 child of type XML element and nothing else (barring comments and whitespaces)
|
|
/// and returns the child
|
|
/// </summary>
|
|
internal static XmlElement GetChildElement(XmlElement parent)
|
|
{
|
|
if (parent == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parent");
|
|
}
|
|
|
|
XmlElement result = null;
|
|
for (int i = 0; i < parent.ChildNodes.Count; ++i)
|
|
{
|
|
XmlNode child = parent.ChildNodes[i];
|
|
if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment)
|
|
{
|
|
continue;
|
|
}
|
|
else if (child.NodeType == XmlNodeType.Element && result == null)
|
|
{
|
|
result = ((XmlElement) child);
|
|
}
|
|
else
|
|
{
|
|
OnUnexpectedChildNodeError(parent, child);
|
|
}
|
|
}
|
|
|
|
if (result == null)
|
|
{
|
|
OnChildNodeTypeMissing(parent, XmlNodeType.Element);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
internal static XmlElement GetChildElement(XmlElement parent, string childLocalName, string childNamespace)
|
|
{
|
|
if (parent == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parent");
|
|
}
|
|
|
|
for (int i = 0; i < parent.ChildNodes.Count; ++i)
|
|
{
|
|
XmlNode child = parent.ChildNodes[i];
|
|
|
|
if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment)
|
|
{
|
|
continue;
|
|
}
|
|
else if (child.NodeType == XmlNodeType.Element)
|
|
{
|
|
if (child.LocalName == childLocalName && child.NamespaceURI == childNamespace)
|
|
{
|
|
return ((XmlElement) child);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OnUnexpectedChildNodeError(parent, child);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
internal static XmlQualifiedName GetValueAsQName(XmlReader reader, string value)
|
|
{
|
|
string prefix;
|
|
string name;
|
|
SplitIntoPrefixAndName(value, out prefix, out name);
|
|
string ns = reader.LookupNamespace(prefix);
|
|
if (ns == null && prefix.Length > 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.CouldNotFindNamespaceForPrefix, prefix)));
|
|
}
|
|
return new XmlQualifiedName(name, ns);
|
|
}
|
|
|
|
internal static string GetWhiteSpace(XmlReader reader)
|
|
{
|
|
string s = null;
|
|
StringBuilder sb = null;
|
|
while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace)
|
|
{
|
|
if (sb != null)
|
|
{
|
|
sb.Append(reader.Value);
|
|
}
|
|
else if (s != null)
|
|
{
|
|
sb = new StringBuilder(s);
|
|
sb.Append(reader.Value);
|
|
s = null;
|
|
}
|
|
else
|
|
{
|
|
s = reader.Value;
|
|
}
|
|
if (!reader.Read())
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return sb != null ? sb.ToString() : s;
|
|
}
|
|
|
|
internal static bool IsWhitespaceOrComment(XmlReader reader)
|
|
{
|
|
if (reader.NodeType == XmlNodeType.Comment)
|
|
{
|
|
return true;
|
|
}
|
|
else if (reader.NodeType == XmlNodeType.Whitespace)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal static void OnChildNodeTypeMissing(string parentName, XmlNodeType expectedNodeType)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.ChildNodeTypeMissing, parentName, expectedNodeType)));
|
|
}
|
|
|
|
internal static void OnChildNodeTypeMissing(XmlElement parent, XmlNodeType expectedNodeType)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.ChildNodeTypeMissing, parent.Name, expectedNodeType)));
|
|
}
|
|
|
|
internal static void OnEmptyElementError(XmlReader r)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.EmptyXmlElementError, r.Name)));
|
|
}
|
|
|
|
internal static void OnEmptyElementError(XmlElement e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.EmptyXmlElementError, e.Name)));
|
|
}
|
|
|
|
internal static void OnEOF()
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedEndOfFile)));
|
|
}
|
|
|
|
internal static void OnNamespaceMissing(string prefix)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.CouldNotFindNamespaceForPrefix, prefix)));
|
|
}
|
|
|
|
internal static void OnRequiredAttributeMissing(string attrName, string elementName)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.RequiredAttributeMissing, attrName, elementName)));
|
|
}
|
|
|
|
internal static void OnRequiredElementMissing(string elementName, string elementNamespace)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.ExpectedElementMissing, elementName, elementNamespace)));
|
|
}
|
|
|
|
internal static void OnUnexpectedChildNodeError(string parentName, XmlReader r)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedXmlChildNode, r.Name, r.NodeType, parentName)));
|
|
}
|
|
|
|
internal static void OnUnexpectedChildNodeError(XmlElement parent, XmlNode n)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnexpectedXmlChildNode, n.Name, n.NodeType, parent.Name)));
|
|
}
|
|
|
|
internal static string ReadEmptyElementAndRequiredAttribute(XmlDictionaryReader reader,
|
|
XmlDictionaryString name, XmlDictionaryString namespaceUri, XmlDictionaryString attributeName,
|
|
out string prefix)
|
|
{
|
|
reader.MoveToStartElement(name, namespaceUri);
|
|
prefix = reader.Prefix;
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
string value = reader.GetAttribute(attributeName, null);
|
|
if (value == null)
|
|
{
|
|
OnRequiredAttributeMissing(attributeName.Value, null);
|
|
}
|
|
reader.Read();
|
|
|
|
if (!isEmptyElement)
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
internal static string GetRequiredNonEmptyAttribute(XmlDictionaryReader reader, XmlDictionaryString name, XmlDictionaryString ns)
|
|
{
|
|
string value = reader.GetAttribute(name, ns);
|
|
if (value == null || value.Length == 0)
|
|
{
|
|
OnRequiredAttributeMissing(name.Value, reader == null ? null : reader.Name);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
internal static byte[] GetRequiredBase64Attribute(XmlDictionaryReader reader, XmlDictionaryString name, XmlDictionaryString ns)
|
|
{
|
|
if (!reader.MoveToAttribute(name.Value, ns == null ? null : ns.Value))
|
|
{
|
|
OnRequiredAttributeMissing(name.Value, ns == null ? null : ns.Value);
|
|
}
|
|
byte[] value = reader.ReadContentAsBase64();
|
|
if (value == null || value.Length == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new XmlException(SR.GetString(SR.EmptyBase64Attribute, name, ns)));
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
internal static string ReadTextElementAsTrimmedString(XmlElement element)
|
|
{
|
|
if (element == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("element");
|
|
}
|
|
|
|
using (XmlReader reader = new XmlNodeReader(element))
|
|
{
|
|
reader.MoveToContent();
|
|
return XmlUtil.Trim(reader.ReadElementContentAsString());
|
|
}
|
|
}
|
|
|
|
internal static void SplitIntoPrefixAndName(string qName, out string prefix, out string name)
|
|
{
|
|
string[] parts = qName.Split(':');
|
|
if (parts.Length > 2)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.InvalidQName));
|
|
}
|
|
|
|
if (parts.Length == 2)
|
|
{
|
|
prefix = parts[0].Trim();
|
|
name = parts[1].Trim();
|
|
}
|
|
else
|
|
{
|
|
prefix = string.Empty;
|
|
name = qName.Trim();
|
|
}
|
|
}
|
|
|
|
internal static void ValidateIdPrefix(string idPrefix)
|
|
{
|
|
if (idPrefix == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("idPrefix"));
|
|
}
|
|
|
|
if (idPrefix.Length == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("idPrefix", SR.GetString(SR.ValueMustBeGreaterThanZero)));
|
|
}
|
|
|
|
if ((!Char.IsLetter(idPrefix[0]) && idPrefix[0] != '_'))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("idPrefix", SR.GetString(SR.InValidateIdPrefix, idPrefix[0])));
|
|
}
|
|
|
|
for (int i = 1; i < idPrefix.Length; i++)
|
|
{
|
|
char c = idPrefix[i];
|
|
if (!Char.IsLetter(c) && !Char.IsNumber(c) && c != '.' && c != '_' && c != '-')
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("idPrefix", SR.GetString(SR.InValidateId, idPrefix[i])));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static UniqueId GetAttributeAsUniqueId(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns)
|
|
{
|
|
return GetAttributeAsUniqueId(reader, localName.Value, (ns != null ? ns.Value : null));
|
|
}
|
|
|
|
static UniqueId GetAttributeAsUniqueId(XmlDictionaryReader reader, string name, string ns)
|
|
{
|
|
if (!reader.MoveToAttribute(name, ns))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
UniqueId id = reader.ReadContentAsUniqueId();
|
|
reader.MoveToElement();
|
|
|
|
return id;
|
|
}
|
|
#if NO
|
|
static public void WriteAttributeStringAsUniqueId(XmlWriter writer, string localName, string ns, UniqueId id)
|
|
{
|
|
WriteAttributeStringAsUniqueId(XmlDictionaryWriter.CreateDictionaryWriter(writer), localName, ns, id);
|
|
}
|
|
|
|
static public void WriteAttributeStringAsUniqueId(XmlWriter writer, string prefix, string localName, string ns, UniqueId id)
|
|
{
|
|
WriteAttributeStringAsUniqueId(XmlDictionaryWriter.CreateDictionaryWriter(writer), prefix, localName, ns, id);
|
|
}
|
|
|
|
static public void WriteAttributeStringAsUniqueId(XmlDictionaryWriter writer, string localName, string ns, UniqueId id)
|
|
{
|
|
WriteAttributeStringAsUniqueId(writer, null, localName, ns, id);
|
|
}
|
|
|
|
static public void WriteAttributeStringAsUniqueId(XmlDictionaryWriter writer, string prefix, string localName, string ns, UniqueId id)
|
|
{
|
|
writer.WriteStartAttribute(prefix, localName, ns);
|
|
writer.WriteValue(id);
|
|
writer.WriteEndAttribute();
|
|
}
|
|
|
|
static public void WriteAttributeStringAsUniqueId(XmlDictionaryWriter writer, XmlDictionaryString localName, XmlDictionaryString ns, UniqueId id)
|
|
{
|
|
WriteAttributeStringAsUniqueId(writer, null, localName, ns, id);
|
|
}
|
|
#endif
|
|
static public void WriteAttributeStringAsUniqueId(XmlDictionaryWriter writer, string prefix, XmlDictionaryString localName, XmlDictionaryString ns, UniqueId id)
|
|
{
|
|
writer.WriteStartAttribute(prefix, localName, ns);
|
|
writer.WriteValue(id);
|
|
writer.WriteEndAttribute();
|
|
}
|
|
|
|
static public void WriteElementStringAsUniqueId(XmlWriter writer, string localName, UniqueId id)
|
|
{
|
|
writer.WriteStartElement(localName);
|
|
writer.WriteValue(id);
|
|
writer.WriteEndElement();
|
|
}
|
|
#if NO
|
|
static public void WriteElementStringAsUniqueId(XmlDictionaryWriter writer, string localName, UniqueId id)
|
|
{
|
|
WriteElementStringAsUniqueId(writer, localName, null, id);
|
|
}
|
|
|
|
static public void WriteElementStringAsUniqueId(XmlDictionaryWriter writer, string localName, string ns, UniqueId id)
|
|
{
|
|
writer.WriteStartElement(localName, ns);
|
|
writer.WriteValue(id);
|
|
writer.WriteEndElement();
|
|
}
|
|
#endif
|
|
static public void WriteElementStringAsUniqueId(XmlDictionaryWriter writer, XmlDictionaryString localName, XmlDictionaryString ns, UniqueId id)
|
|
{
|
|
writer.WriteStartElement(localName, ns);
|
|
writer.WriteValue(id);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
static public void WriteElementContentAsInt64(XmlDictionaryWriter writer, XmlDictionaryString localName, XmlDictionaryString ns, Int64 value)
|
|
{
|
|
writer.WriteStartElement(localName, ns);
|
|
writer.WriteValue(value);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
static public Int64 ReadElementContentAsInt64(XmlDictionaryReader reader)
|
|
{
|
|
reader.ReadFullStartElement();
|
|
Int64 i = reader.ReadContentAsLong();
|
|
reader.ReadEndElement();
|
|
return i;
|
|
}
|
|
|
|
static public void WriteStringAsUniqueId(XmlDictionaryWriter writer, UniqueId id)
|
|
{
|
|
writer.WriteValue(id);
|
|
}
|
|
|
|
static public UniqueId ReadElementStringAsUniqueId(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns)
|
|
{
|
|
if (reader.IsStartElement(localName, ns) && reader.IsEmptyElement)
|
|
{
|
|
reader.Read();
|
|
return new UniqueId(string.Empty);
|
|
}
|
|
|
|
reader.ReadStartElement(localName, ns);
|
|
UniqueId id = reader.ReadContentAsUniqueId();
|
|
reader.ReadEndElement();
|
|
return id;
|
|
}
|
|
|
|
static public UniqueId ReadElementStringAsUniqueId(XmlDictionaryReader reader)
|
|
{
|
|
if (reader.IsStartElement() && reader.IsEmptyElement)
|
|
{
|
|
reader.Read();
|
|
return new UniqueId(string.Empty);
|
|
}
|
|
|
|
reader.ReadStartElement();
|
|
UniqueId id = reader.ReadContentAsUniqueId();
|
|
reader.ReadEndElement();
|
|
return id;
|
|
}
|
|
#if NO
|
|
internal static UniqueId ReadEmptyElementAndRequiredAttributeAsUniqueId(XmlDictionaryReader reader, XmlDictionaryString name, XmlDictionaryString namespaceUri, XmlDictionaryString attributeName, out string prefix)
|
|
{
|
|
string s = ReadEmptyElementAndRequiredAttribute(reader, name, namespaceUri, attributeName, out prefix);
|
|
|
|
if (s == null)
|
|
return null;
|
|
|
|
return new UniqueId(s);
|
|
}
|
|
|
|
static public UniqueId ReadTextElementAsUniqueId(XmlDictionaryReader reader)
|
|
{
|
|
return new UniqueId(ReadTextElement(reader));
|
|
}
|
|
#endif
|
|
static public UniqueId ReadTextElementAsUniqueId(XmlElement element)
|
|
{
|
|
return new UniqueId(ReadTextElementAsTrimmedString(element));
|
|
}
|
|
#if NO
|
|
static public UniqueId GetAttributeAsUniqueId(XmlElement element, string localName, string ns)
|
|
{
|
|
XmlAttribute attr = element.Attributes[localName, ns];
|
|
|
|
if (attr == null)
|
|
return null;
|
|
|
|
return new UniqueId(attr.Value);
|
|
}
|
|
#endif
|
|
}
|
|
}
|