|
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Xml;
using System.Xml.Linq;
using System.Runtime.Versioning;
namespace System.Xml.Schema
{
internal class XNodeValidator
{
XmlSchemaSet schemas;
ValidationEventHandler validationEventHandler;
XObject source;
bool addSchemaInfo;
XmlNamespaceManager namespaceManager;
XmlSchemaValidator validator;
Dictionary<XmlSchemaInfo, XmlSchemaInfo> schemaInfos;
ArrayList defaultAttributes;
XName xsiTypeName;
XName xsiNilName;
public XNodeValidator(XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) {
this.schemas = schemas;
this.validationEventHandler = validationEventHandler;
XNamespace xsi = XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance");
xsiTypeName = xsi.GetName("type");
xsiNilName = xsi.GetName("nil");
}
public void Validate(XObject source, XmlSchemaObject partialValidationType, bool addSchemaInfo) {
this.source = source;
this.addSchemaInfo = addSchemaInfo;
XmlSchemaValidationFlags validationFlags = XmlSchemaValidationFlags.AllowXmlAttributes;
XmlNodeType nt = source.NodeType;
switch (nt) {
case XmlNodeType.Document:
source = ((XDocument)source).Root;
if (source == null) throw new InvalidOperationException(System.Xml.Linq.Res.GetString(System.Xml.Linq.Res.InvalidOperation_MissingRoot));
validationFlags |= XmlSchemaValidationFlags.ProcessIdentityConstraints;
break;
case XmlNodeType.Element:
break;
case XmlNodeType.Attribute:
if (((XAttribute)source).IsNamespaceDeclaration) goto default;
if (source.Parent == null) throw new InvalidOperationException(System.Xml.Linq.Res.GetString(System.Xml.Linq.Res.InvalidOperation_MissingParent));
break;
default:
throw new InvalidOperationException(System.Xml.Linq.Res.GetString(System.Xml.Linq.Res.InvalidOperation_BadNodeType, nt));
}
namespaceManager = new XmlNamespaceManager(schemas.NameTable);
PushAncestorsAndSelf(source.Parent);
validator = new XmlSchemaValidator(schemas.NameTable, schemas, namespaceManager, validationFlags);
validator.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
validator.XmlResolver = null;
if (partialValidationType != null) {
validator.Initialize(partialValidationType);
}
else {
validator.Initialize();
}
IXmlLineInfo orginal = SaveLineInfo(source);
if (nt == XmlNodeType.Attribute) {
ValidateAttribute((XAttribute)source);
}
else {
ValidateElement((XElement)source);
}
validator.EndValidation();
RestoreLineInfo(orginal);
}
XmlSchemaInfo GetDefaultAttributeSchemaInfo(XmlSchemaAttribute sa) {
XmlSchemaInfo si = new XmlSchemaInfo();
si.IsDefault = true;
si.IsNil = false;
si.SchemaAttribute = sa;
XmlSchemaSimpleType st = sa.AttributeSchemaType;
si.SchemaType = st;
if (st.Datatype.Variety == XmlSchemaDatatypeVariety.Union) {
string value = GetDefaultValue(sa);
foreach (XmlSchemaSimpleType mt in ((XmlSchemaSimpleTypeUnion)st.Content).BaseMemberTypes) {
object typedValue = null;
try {
typedValue = mt.Datatype.ParseValue(value, schemas.NameTable, namespaceManager);
}
catch (XmlSchemaException) {
}
if (typedValue != null) {
si.MemberType = mt;
break;
}
}
}
si.Validity = XmlSchemaValidity.Valid;
return si;
}
string GetDefaultValue(XmlSchemaAttribute sa) {
XmlQualifiedName name = sa.RefName;
if (!name.IsEmpty) {
sa = schemas.GlobalAttributes[name] as XmlSchemaAttribute;
if (sa == null) return null;
}
string s = sa.FixedValue;
if (s != null) return s;
return sa.DefaultValue;
}
string GetDefaultValue(XmlSchemaElement se) {
XmlQualifiedName name = se.RefName;
if (!name.IsEmpty) {
se = schemas.GlobalElements[name] as XmlSchemaElement;
if (se == null) return null;
}
string s = se.FixedValue;
if (s != null) return s;
return se.DefaultValue;
}
void ReplaceSchemaInfo(XObject o, XmlSchemaInfo schemaInfo) {
if (schemaInfos == null) {
schemaInfos = new Dictionary<XmlSchemaInfo, XmlSchemaInfo>(new XmlSchemaInfoEqualityComparer());
}
XmlSchemaInfo si = o.Annotation<XmlSchemaInfo>();
if (si != null) {
if (!schemaInfos.ContainsKey(si)) {
schemaInfos.Add(si, si);
}
o.RemoveAnnotations<XmlSchemaInfo>();
}
if (!schemaInfos.TryGetValue(schemaInfo, out si)) {
si = schemaInfo;
schemaInfos.Add(si, si);
}
o.AddAnnotation(si);
}
void PushAncestorsAndSelf(XElement e) {
while (e != null) {
XAttribute a = e.lastAttr;
if (a != null) {
do {
a = a.next;
if (a.IsNamespaceDeclaration) {
string localName = a.Name.LocalName;
if (localName == "xmlns") {
localName = string.Empty;
}
if (!namespaceManager.HasNamespace(localName)) {
namespaceManager.AddNamespace(localName, a.Value);
}
}
} while (a != e.lastAttr);
}
e = e.parent as XElement;
}
}
void PushElement(XElement e, ref string xsiType, ref string xsiNil) {
namespaceManager.PushScope();
XAttribute a = e.lastAttr;
if (a != null) {
do {
a = a.next;
if (a.IsNamespaceDeclaration) {
string localName = a.Name.LocalName;
if (localName == "xmlns") {
localName = string.Empty;
}
namespaceManager.AddNamespace(localName, a.Value);
}
else {
XName name = a.Name;
if (name == xsiTypeName) {
xsiType = a.Value;
}
else if (name == xsiNilName) {
xsiNil = a.Value;
}
}
} while (a != e.lastAttr);
}
}
IXmlLineInfo SaveLineInfo(XObject source) {
IXmlLineInfo previousLineInfo = validator.LineInfoProvider;
validator.LineInfoProvider = source as IXmlLineInfo;
return previousLineInfo;
}
void RestoreLineInfo(IXmlLineInfo originalLineInfo) {
validator.LineInfoProvider = originalLineInfo;
}
void ValidateAttribute(XAttribute a) {
IXmlLineInfo original = SaveLineInfo(a);
XmlSchemaInfo si = addSchemaInfo ? new XmlSchemaInfo() : null;
source = a;
validator.ValidateAttribute(a.Name.LocalName, a.Name.NamespaceName, a.Value, si);
if (addSchemaInfo) {
ReplaceSchemaInfo(a, si);
}
RestoreLineInfo(original);
}
void ValidateAttributes(XElement e) {
XAttribute a = e.lastAttr;
IXmlLineInfo orginal = SaveLineInfo(a);
if (a != null) {
do {
a = a.next;
if (!a.IsNamespaceDeclaration) {
ValidateAttribute(a);
}
} while (a != e.lastAttr);
source = e;
}
if (addSchemaInfo) {
if (defaultAttributes == null) {
defaultAttributes = new ArrayList();
}
else {
defaultAttributes.Clear();
}
validator.GetUnspecifiedDefaultAttributes(defaultAttributes);
foreach (XmlSchemaAttribute sa in defaultAttributes) {
a = new XAttribute(XNamespace.Get(sa.QualifiedName.Namespace).GetName(sa.QualifiedName.Name), GetDefaultValue(sa));
ReplaceSchemaInfo(a, GetDefaultAttributeSchemaInfo(sa));
e.Add(a);
}
}
RestoreLineInfo(orginal);
}
// SxS: This method does not expose any resources to the caller and passes null as resource names to
// XmlSchemaValidator.ValidateElement (annotated with ResourceExposure(ResourceScope.None).
// It's OK to suppress the SxS warning.
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
[ResourceExposure(ResourceScope.None)]
void ValidateElement(XElement e) {
XmlSchemaInfo si = addSchemaInfo ? new XmlSchemaInfo() : null;
string xsiType = null;
string xsiNil = null;
PushElement(e, ref xsiType, ref xsiNil);
IXmlLineInfo original = SaveLineInfo(e);
source = e;
validator.ValidateElement(e.Name.LocalName, e.Name.NamespaceName, si, xsiType, xsiNil, null, null);
ValidateAttributes(e);
validator.ValidateEndOfAttributes(si);
ValidateNodes(e);
validator.ValidateEndElement(si);
if (addSchemaInfo) {
if (si.Validity == XmlSchemaValidity.Valid && si.IsDefault) {
e.Value = GetDefaultValue(si.SchemaElement);
}
ReplaceSchemaInfo(e, si);
}
RestoreLineInfo(original);
namespaceManager.PopScope();
}
void ValidateNodes(XElement e) {
XNode n = e.content as XNode;
IXmlLineInfo orginal = SaveLineInfo(n);
if (n != null) {
do {
n = n.next;
XElement c = n as XElement;
if (c != null) {
ValidateElement(c);
}
else {
XText t = n as XText;
if (t != null) {
string s = t.Value;
if (s.Length > 0) {
validator.LineInfoProvider = t as IXmlLineInfo;
validator.ValidateText(s);
}
}
}
} while (n != e.content);
source = e;
}
else {
string s = e.content as string;
if (s != null && s.Length > 0) {
validator.ValidateText(s);
}
}
RestoreLineInfo(orginal);
}
void ValidationCallback(object sender, ValidationEventArgs e) {
if (validationEventHandler != null) {
validationEventHandler(source, e);
}
else if (e.Severity == XmlSeverityType.Error) {
throw e.Exception;
}
}
}
internal class XmlSchemaInfoEqualityComparer : IEqualityComparer<XmlSchemaInfo>
{
public bool Equals(XmlSchemaInfo si1, XmlSchemaInfo si2) {
if (si1 == si2) return true;
if (si1 == null || si2 == null) return false;
return si1.ContentType == si2.ContentType &&
si1.IsDefault == si2.IsDefault &&
si1.IsNil == si2.IsNil &&
(object)si1.MemberType == (object)si2.MemberType &&
(object)si1.SchemaAttribute == (object)si2.SchemaAttribute &&
(object)si1.SchemaElement == (object)si2.SchemaElement &&
(object)si1.SchemaType == (object)si2.SchemaType &&
si1.Validity == si2.Validity;
}
public int GetHashCode(XmlSchemaInfo si) {
if (si == null) return 0;
int h = (int)si.ContentType;
if (si.IsDefault) {
h ^= 1;
}
if (si.IsNil) {
h ^= 1;
}
XmlSchemaSimpleType memberType = si.MemberType;
if (memberType != null) {
h ^= memberType.GetHashCode();
}
XmlSchemaAttribute schemaAttribute = si.SchemaAttribute;
if (schemaAttribute != null) {
h ^= schemaAttribute.GetHashCode();
}
XmlSchemaElement schemaElement = si.SchemaElement;
if (schemaElement != null) {
h ^= schemaElement.GetHashCode();
}
XmlSchemaType schemaType = si.SchemaType;
if (schemaType != null) {
h ^= schemaType.GetHashCode();
}
h ^= (int)si.Validity;
return h;
}
}
/// <summary>
/// Extension methods
/// </summary>
public static class Extensions
{
/// <summary>
/// Gets the schema information that has been assigned to the <see cref="XElement"/> as a result of schema validation.
/// </summary>
/// <param name="source">Extension point</param>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Reviewed by the design group.")]
public static IXmlSchemaInfo GetSchemaInfo(this XElement source) {
if (source == null) throw new ArgumentNullException("source");
return source.Annotation<IXmlSchemaInfo>();
}
/// <summary>
/// Gets the schema information that has been assigned to the <see cref="XAttribute"/> as a result of schema validation.
/// </summary>
/// <param name="source">Extension point</param>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Reviewed by the design group.")]
public static IXmlSchemaInfo GetSchemaInfo(this XAttribute source) {
if (source == null) throw new ArgumentNullException("source");
return source.Annotation<IXmlSchemaInfo>();
}
/// <summary>
/// Validate a <see cref="XDocument"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/>
/// that receives schema validation warnings and errors encountered during schema
/// validation</param>
public static void Validate(this XDocument source, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) {
source.Validate(schemas, validationEventHandler, false);
}
/// <summary>
/// Validate a <see cref="XDocument"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/>
/// that receives schema validation warnings and errors encountered during schema
/// validation</param>
/// <param name="addSchemaInfo">If enabled the <see cref="XDocument"/> and the corresponding
/// subtree is augmented with PSVI in the form of <see cref="IXmlSchemaInfo"/> annotations,
/// default attributes and default element values</param>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Reviewed by the design group.")]
public static void Validate(this XDocument source, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo) {
if (source == null) throw new ArgumentNullException("source");
if (schemas == null) throw new ArgumentNullException("schemas");
new XNodeValidator(schemas, validationEventHandler).Validate(source, null, addSchemaInfo);
}
/// <summary>
/// Validate a <see cref="XElement"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaElement"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
public static void Validate(this XElement source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) {
source.Validate(partialValidationType, schemas, validationEventHandler, false);
}
/// <summary>
/// Validate a <see cref="XElement"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaElement"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
/// <param name="addSchemaInfo">If enabled the <see cref="XElement"/> and the corresponding
/// subtree is augmented with PSVI in the form of <see cref="IXmlSchemaInfo"/> annotations,
/// default attributes and default element values</param>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Reviewed by the design group.")]
public static void Validate(this XElement source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo) {
if (source == null) throw new ArgumentNullException("source");
if (partialValidationType == null) throw new ArgumentNullException("partialValidationType");
if (schemas == null) throw new ArgumentNullException("schemas");
new XNodeValidator(schemas, validationEventHandler).Validate(source, partialValidationType, addSchemaInfo);
}
/// <summary>
/// Validate a <see cref="XAttribute"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaAttribute"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) {
source.Validate(partialValidationType, schemas, validationEventHandler, false);
}
/// <summary>
/// Validate a <see cref="XAttribute"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaAttribute"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
/// <param name="addSchemaInfo">If enabled the <see cref="XAttribute"/> is augmented with PSVI
/// in the form of <see cref="IXmlSchemaInfo"/> annotations, default attributes and
/// default element values</param>
[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Reviewed by the design group.")]
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo) {
if (source == null) throw new ArgumentNullException("source");
if (partialValidationType == null) throw new ArgumentNullException("partialValidationType");
if (schemas == null) throw new ArgumentNullException("schemas");
new XNodeValidator(schemas, validationEventHandler).Validate(source, partialValidationType, addSchemaInfo);
}
}
}
|