// Constructor.
public XmlDTDReader(XmlParserContext context)
: base(null)
{
this.context = context;
this.input = null;
this.resolver = null;
}
public void Load(XmlReader stylesheet, XmlResolver resolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException(nameof(stylesheet));
}
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver);
}
// Initialize this dtd reader.
public void Init
(XmlParserInput input,
XmlResolver resolver)
{
base.ErrorHandler = input.ErrorHandler;
this.input = new XmlDTDParserInput(input, context.NameTable);
this.resolver = resolver;
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException(nameof(stylesheet));
}
Load(stylesheet.CreateNavigator(), resolver);
}
public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver)
{
Debug.Assert(compiler != null);
_compiler = compiler;
_xmlResolver = xmlResolver ?? XmlNullResolver.Singleton;
XmlReader reader = stylesheet as XmlReader;
if (reader != null)
{
_readerSettings = new QueryReaderSettings(reader);
Load(reader);
}
else
{
// We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings.
string uri = stylesheet as string;
if (uri != null)
{
// If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver
XmlResolver origResolver = xmlResolver;
if (xmlResolver == null || xmlResolver == XmlNullResolver.Singleton)
origResolver = new XmlUrlResolver();
Uri resolvedUri = origResolver.ResolveUri(null, uri);
if (resolvedUri == null)
{
throw new XslLoadException(SR.Xslt_CantResolve, uri);
}
_readerSettings = new QueryReaderSettings(new NameTable());
using (reader = CreateReader(resolvedUri, origResolver))
{
Load(reader);
}
}
else
{
IXPathNavigable navigable = stylesheet as IXPathNavigable;
if (navigable != null)
{
reader = XPathNavigatorReader.Create(navigable.CreateNavigator());
_readerSettings = new QueryReaderSettings(reader.NameTable);
Load(reader);
}
else
{
Debug.Fail("Should never get here");
}
}
}
Debug.Assert(compiler.Root != null);
compiler.StartApplyTemplates = f.ApplyTemplates(nullMode);
ProcessOutputSettings();
foreach (AttributeSet attSet in compiler.AttributeSets.Values)
{
CheckAttributeSetsDfs(attSet); // Check attribute sets for circular references using dfs marking method
}
}
public void Load(XPathNavigator stylesheet, XmlResolver resolver) {
if (stylesheet == null) {
throw new ArgumentNullException("stylesheet");
}
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(stylesheet, resolver, /*evidence:*/null);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = new XmlUrlResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
/// <summary>
/// Default document as XPathNavigator.
/// </summary>
public override void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
if (contextDocument != null)
Execute(contextDocument.CreateNavigator(), dataSources, argumentList, results, false);
else
Execute(null, dataSources, argumentList, results, false);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public void Load(string url, XmlResolver resolver) {
XmlTextReaderImpl tr = new XmlTextReaderImpl(url); {
tr.XmlResolver = resolver;
}
Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(tr.BaseURI); // We should ask BaseURI before we start reading because it's changing with each node
if (resolver == null) {
resolver = new XmlNullResolver();
}
Compile(Compiler.LoadDocument(tr).CreateNavigator(), resolver, evidence);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
public BaseValidator(BaseValidator other) {
reader = other.reader;
schemaCollection = other.schemaCollection;
eventHandler = other.eventHandler;
nameTable = other.nameTable;
schemaNames = other.schemaNames;
positionInfo = other.positionInfo;
xmlResolver = other.xmlResolver;
baseUri = other.baseUri;
elementName = other.elementName;
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable) {
if (nametable == null) {
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
isThreadSafe = true;
if (isThreadSafe) {
wLock = new ReaderWriterLock();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable) {
if (nametable == null) {
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
xmlResolver = new XmlUrlResolver();
isThreadSafe = true;
if (isThreadSafe) {
wLock = new ReaderWriterLock();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable)
{
if (nametable == null)
{
throw new ArgumentNullException(nameof(nametable));
}
_nameTable = nametable;
_collection = Hashtable.Synchronized(new Hashtable());
_xmlResolver = null;
_isThreadSafe = true;
if (_isThreadSafe)
{
_wLock = new object();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable)
{
if (nametable == null)
{
throw new ArgumentNullException(nameof(nametable));
}
_nameTable = nametable;
_collection = Hashtable.Synchronized(new Hashtable());
_xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
_isThreadSafe = true;
if (_isThreadSafe)
{
_wLock = new object();
}
}
public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver) {
Debug.Assert(compiler != null);
this.compiler = compiler;
this.xmlResolver = xmlResolver ?? XmlNullResolver.Singleton;
XmlReader reader = stylesheet as XmlReader;
if (reader != null) {
readerSettings = new QueryReaderSettings(reader);
LoadStylesheet(reader, /*include:*/false);
} else {
// We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings.
string uri = stylesheet as string;
if (uri != null) {
// If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver
XmlResolver origResolver = xmlResolver ?? new XmlUrlResolver();
Uri resolvedUri = origResolver.ResolveUri(null, uri);
if (resolvedUri == null) {
throw new XslLoadException(Res.Xslt_CantResolve, uri);
}
readerSettings = new QueryReaderSettings(new NameTable());
using (reader = CreateReader(resolvedUri, origResolver)) {
LoadStylesheet(reader, /*include:*/false);
}
} else {
IXPathNavigable navigable = stylesheet as IXPathNavigable;
if (navigable != null) {
reader = XPathNavigatorReader.Create(navigable.CreateNavigator());
readerSettings = new QueryReaderSettings(reader.NameTable);
LoadStylesheet(reader, /*include:*/false);
} else {
Debug.Fail("Should never get here");
}
}
}
Process();
}
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver)
{
CheckArguments(input, results);
this.CheckCommand();
this.command.Execute(input.CreateNavigator(), documentResolver, arguments, results);
}
// creates individual validator with schema
// (which should be provided in derived constructor).
public abstract XmlReader CreateValidator(XmlReader reader,
XmlResolver resolver);
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Load6"]/*' />
public void Load(XPathNavigator stylesheet, XmlResolver resolver)
{
Compile(stylesheet, resolver);
}
// --------------------------------------------------------------------------------------------------------------
// LoadXSL_Resolver
// -------------------------------------------------------------------------------------------------------------
public int LoadXSL_Resolver(string _strXslFile, XmlResolver xr, InputType inputType, ReaderType readerType)
{
_strXslFile = FullFilePath(_strXslFile);
#pragma warning disable 0618
xslt = new XslTransform();
#pragma warning restore 0618
switch (inputType)
{
case InputType.URI:
_output.WriteLine("Loading style sheet as URI {0}", _strXslFile);
xslt.Load(_strXslFile, xr);
break;
case InputType.Reader:
switch (readerType)
{
case ReaderType.XmlTextReader:
XmlTextReader trTemp = new XmlTextReader(_strXslFile);
try
{
_output.WriteLine("Loading style sheet as XmlTextReader {0}", _strXslFile);
xslt.Load(trTemp, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (trTemp != null)
{
trTemp.Dispose();
}
}
break;
case ReaderType.XmlNodeReader:
XmlDocument docTemp = new XmlDocument();
docTemp.Load(_strXslFile);
XmlNodeReader nrTemp = new XmlNodeReader(docTemp);
try
{
_output.WriteLine("Loading style sheet as XmlNodeReader {0}", _strXslFile);
xslt.Load(nrTemp, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (nrTemp != null)
{
nrTemp.Dispose();
}
}
break;
case ReaderType.XmlValidatingReader:
default:
#pragma warning disable 0618
XmlValidatingReader vrTemp = new XmlValidatingReader(new XmlTextReader(_strXslFile));
#pragma warning restore 0618
vrTemp.ValidationType = ValidationType.None;
vrTemp.EntityHandling = EntityHandling.ExpandEntities;
try
{
_output.WriteLine("Loading style sheet as XmlValidatingReader {0}", _strXslFile);
xslt.Load(vrTemp, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (vrTemp != null)
{
vrTemp.Dispose();
}
}
break;
}
break;
case InputType.Navigator:
#pragma warning disable 0618
XmlValidatingReader xrLoad = new XmlValidatingReader(new XmlTextReader(_strXslFile));
#pragma warning restore 0618
XPathDocument xdTemp = new XPathDocument(xrLoad, XmlSpace.Preserve);
xrLoad.Dispose();
_output.WriteLine("Loading style sheet as Navigator {0}", _strXslFile);
xslt.Load(xdTemp, xr);
break;
}
return(1);
}
// --------------------------------------------------------------------------------------------------------------
// TransformResolver
// -------------------------------------------------------------------------------------------------------------
public int TransformResolver(string szXmlFile, TransformType transformType, DocType docType, XmlResolver xr)
{
// Default value of errorCase is false
return(TransformResolver(szXmlFile, xr, false, transformType, docType));
}
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output, XmlResolver resolver)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
Transform(input.CreateNavigator(), args, output, resolver);
}
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Load5"]/*' />
public void Load(XmlReader stylesheet, XmlResolver resolver)
{
Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver);
}
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver)
{
CheckArguments(input, results);
this.CheckCommand();
this.command.Execute(input, documentResolver, arguments, results);
}
private CompilerResults LoadInternal(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException("stylesheet");
}
if (settings == null)
{
settings = XsltSettings.Default;
}
this.CompileXsltToQil(stylesheet, settings, stylesheetResolver);
CompilerError firstError = this.GetFirstError();
if (firstError != null)
{
throw new XslLoadException(firstError);
}
if (!settings.CheckOnly)
{
this.CompileQilToMsil(settings);
}
return(this.compilerResults);
}
private void CompileXsltToQil(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
this.compilerResults = new Compiler(settings, this.enableDebug, null).Compile(stylesheet, stylesheetResolver, out this.qil);
}
private XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile, XmlResolver resolver)
{
int errorCount = 0;
if (schema != null)
{
if (schema.ErrorCount == 0 && compile)
{
if (!schema.CompileSchema(this, resolver, schemaInfo, ns, _validationEventHandler, _nameTable, true))
{
errorCount = 1;
}
ns = schema.TargetNamespace == null ? string.Empty : schema.TargetNamespace;
}
errorCount += schema.ErrorCount;
}
else
{
errorCount += schemaInfo.ErrorCount;
//ns = ns == null? string.Empty : NameTable.Add(ns);
ns = NameTable.Add(ns); //Added without checking for ns == null, since XDR cannot have null namespace
}
if (errorCount == 0)
{
XmlSchemaCollectionNode node = new XmlSchemaCollectionNode();
node.NamespaceURI = ns;
node.SchemaInfo = schemaInfo;
node.Schema = schema;
Add(ns, node);
return(schema);
}
return(null);
}
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Load7"]/*' />
public void Load(IXPathNavigable stylesheet, XmlResolver resolver)
{
Load(stylesheet.CreateNavigator(), resolver);
}
internal CanonicalXml(XmlDocument document, XmlResolver resolver) : this(document, resolver, false)
{
}
public static CompilerErrorCollection CompileToType(XmlReader stylesheet, XsltSettings settings, XmlResolver stylesheetResolver, bool debug, TypeBuilder typeBuilder, string scriptAssemblyPath)
{
QilExpression expression;
if (stylesheet == null)
{
throw new ArgumentNullException("stylesheet");
}
if (typeBuilder == null)
{
throw new ArgumentNullException("typeBuilder");
}
if (settings == null)
{
settings = XsltSettings.Default;
}
if (settings.EnableScript && (scriptAssemblyPath == null))
{
throw new ArgumentNullException("scriptAssemblyPath");
}
if (scriptAssemblyPath != null)
{
scriptAssemblyPath = Path.GetFullPath(scriptAssemblyPath);
}
CompilerErrorCollection errors = new Compiler(settings, debug, scriptAssemblyPath).Compile(stylesheet, stylesheetResolver, out expression).Errors;
if (!errors.HasErrors)
{
if (GeneratedCodeCtor == null)
{
GeneratedCodeCtor = typeof(GeneratedCodeAttribute).GetConstructor(new Type[] { typeof(string), typeof(string) });
}
typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(GeneratedCodeCtor, new object[] { typeof(XslCompiledTransform).FullName, "4.0.0.0" }));
new XmlILGenerator().Generate(expression, typeBuilder);
}
return(errors);
}
/// <summary>
/// 构造函数
/// </summary>
public XmlDocument_XxeFixed(XmlResolver xmlResolver = null)
{
XmlResolver = null;
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using
/// run-time parameters as provided by the XsltArgumentList. The default document
/// is mapped into the XmlResolver with the provided name. The results are returned
/// as an IList.
/// </summary>
public IList Evaluate(string contextDocumentUri, XmlResolver dataSources, XsltArgumentList argumentList)
{
XmlCachedSequenceWriter seqwrt = new XmlCachedSequenceWriter();
Execute(contextDocumentUri, dataSources, argumentList, seqwrt);
return seqwrt.ResultSequence;
}
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output, XmlResolver resolver)
{
CheckCommand();
Processor processor = new Processor(input, args, resolver, _CompiledStylesheet, _QueryStore, _RootAction, _debugger);
processor.Execute(output);
}
/// <summary>
/// Execute the dynamic assembly generated by the XmlILGenerator.
/// </summary>
public void Execute(object defaultDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter writer)
{
try
{
if (writer is XmlAsyncCheckWriter)
{
writer = ((XmlAsyncCheckWriter)writer).CoreWriter;
}
// Try to extract a RawWriter
XmlWellFormedWriter wellFormedWriter = writer as XmlWellFormedWriter;
if (wellFormedWriter != null &&
wellFormedWriter.RawWriter != null &&
wellFormedWriter.WriteState == WriteState.Start &&
wellFormedWriter.Settings.ConformanceLevel != ConformanceLevel.Document)
{
// Extracted RawWriter from WellFormedWriter
Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(wellFormedWriter.RawWriter));
}
else
{
// Wrap Writer in RawWriter
Execute(defaultDocument, dataSources, argumentList, new XmlMergeSequenceWriter(new XmlRawWriterWrapper(writer)));
}
}
finally
{
writer.Flush();
}
}
public int TransformResolver(string szXmlFile, XmlResolver xr, bool errorCase, TransformType transformType, DocType docType)
{
lock (s_outFileMemoryLock)
{
szXmlFile = FullFilePath(szXmlFile);
_output.WriteLine("Loading XML {0}", szXmlFile);
IXPathNavigable xd = LoadXML(szXmlFile, docType);
_output.WriteLine("Executing transform");
xrXSLT = null;
Stream strmTemp = null;
switch (transformType)
{
case TransformType.Reader:
xrXSLT = xslt.Transform(xd, null, xr);
using (FileStream outFile = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite))
using (XmlWriter writer = XmlWriter.Create(outFile))
{
writer.WriteNode(xrXSLT, true);
}
if (errorCase)
{
try
{
while (xrXSLT.Read())
{
}
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (xrXSLT != null)
{
xrXSLT.Dispose();
}
}
}
break;
case TransformType.Stream:
try
{
strmTemp = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite);
xslt.Transform(xd, null, strmTemp, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (strmTemp != null)
{
strmTemp.Dispose();
}
}
break;
case TransformType.Writer:
XmlWriter xw = null;
try
{
xw = new XmlTextWriter(_strOutFile, Encoding.UTF8);
xw.WriteStartDocument();
xslt.Transform(xd, null, xw, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (xw != null)
{
xw.Dispose();
}
}
break;
case TransformType.TextWriter:
TextWriter tw = null;
try
{
using (FileStream outFile = new FileStream(_strOutFile, FileMode.Create, FileAccess.Write))
{
tw = new StreamWriter(outFile, Encoding.UTF8);
xslt.Transform(xd, null, tw, xr);
}
}
catch (Exception ex)
{
throw (ex);
}
break;
}
return(1);
}
}
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// </summary>
internal XmlQueryRuntime(XmlILCommand cmd, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
{
Debug.Assert(cmd != null, "Command object must be non-null");
string[] names = cmd.Names;
Int32Pair[] filters = cmd.Filters;
WhitespaceRuleLookup wsRules;
int i;
this.cmd = cmd;
// Early-Bound Library Objects
wsRules = (cmd.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(cmd.WhitespaceRules) : null;
this.ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
this.xsltLib = null;
this.earlyInfo = cmd.EarlyBound;
this.earlyObjects = (this.earlyInfo != null) ? new object[earlyInfo.Length] : null;
// Global variables and parameters
this.globalNames = cmd.GlobalNames;
this.globalValues = (this.globalNames != null) ? new object[this.globalNames.Length] : null;
// Names
this.nameTableQuery = this.ctxt.QueryNameTable;
this.atomizedNames = null;
if (names != null)
{
// Atomize all names in "nameTableQuery". Use names from the default data source's
// name table when possible.
XmlNameTable nameTableDefault = ctxt.DefaultNameTable;
this.atomizedNames = new string[names.Length];
if (nameTableDefault != this.nameTableQuery && nameTableDefault != null)
{
// Ensure that atomized names from the default data source are added to the
// name table used in this query
for (i = 0; i < names.Length; i++)
{
string name = nameTableDefault.Get(names[i]);
this.atomizedNames[i] = this.nameTableQuery.Add(name ?? names[i]);
}
}
else
{
// Enter names into nametable used in this query
for (i = 0; i < names.Length; i++)
{
this.atomizedNames[i] = this.nameTableQuery.Add(names[i]);
}
}
}
// Name filters
this.filters = null;
if (filters != null)
{
// Construct name filters. Each pair of integers in the filters[] array specifies the
// (localName, namespaceUri) of the NameFilter to be created.
this.filters = new XmlNavigatorFilter[filters.Length];
for (i = 0; i < filters.Length; i++)
{
this.filters[i] = XmlNavNameFilter.Create(this.atomizedNames[filters[i].Left], this.atomizedNames[filters[i].Right]);
}
}
// Prefix maping lists
this.prefixMappingsList = cmd.PrefixMappingsList;
// Xml types
this.types = cmd.Types;
// Xml collations
this.collations = cmd.Collations;
// Document ordering
this.docOrderCmp = new DocumentOrderComparer();
// Indexes
this.indexes = null;
// Output construction
this.stkOutput = new Stack <XmlQueryOutput>(16);
this.output = new XmlQueryOutput(this, seqWrt);
}
public void CallTransform(XslTransform xslt, string szFullFilename, string _strOutFile, XmlResolver resolver)
{
lock (s_outFileMemoryLock)
{
xslt.Transform(szFullFilename, _strOutFile, resolver);
}
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using run-time parameters
/// as provided by the XsltArgumentList. The default document is mapped into the XmlResolver with the
/// provided name. The results are output to the provided XmlWriter.
/// </summary>
public void Execute(string contextDocumentUri, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
Execute(contextDocumentUri, dataSources, argumentList, results, false);
}
// What we want to do is pump the input throug the TransformChain and then
// hash the output of the chain document is the document context for resolving relative references
internal byte[] CalculateHashValue(XmlDocument document, CanonicalXmlNodeList refList)
{
// refList is a list of elements that might be targets of references
// Now's the time to create our hashing algorithm
_hashAlgorithm = CryptoHelpers.CreateFromName <HashAlgorithm>(_digestMethod);
if (_hashAlgorithm == null)
{
throw new CryptographicException(SR.Cryptography_Xml_CreateHashAlgorithmFailed);
}
// Let's go get the target.
string baseUri = (document == null ? System.Environment.CurrentDirectory + "\\" : document.BaseURI);
Stream hashInputStream = null;
WebResponse response = null;
Stream inputStream = null;
XmlResolver resolver = null;
byte[] hashval = null;
try
{
switch (_refTargetType)
{
case ReferenceTargetType.Stream:
// This is the easiest case. We already have a stream, so just pump it through the TransformChain
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
hashInputStream = TransformChain.TransformToOctetStream((Stream)_refTarget, resolver, baseUri);
break;
case ReferenceTargetType.UriReference:
// Second-easiest case -- dereference the URI & pump through the TransformChain
// handle the special cases where the URI is null (meaning whole doc)
// or the URI is just a fragment (meaning a reference to an embedded Object)
if (_uri == null)
{
// We need to create a DocumentNavigator out of the XmlElement
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
// In the case of a Uri-less reference, we will simply pass null to the transform chain.
// The first transform in the chain is expected to know how to retrieve the data to hash.
hashInputStream = TransformChain.TransformToOctetStream((Stream)null, resolver, baseUri);
}
else if (_uri.Length == 0)
{
// This is the self-referential case. First, check that we have a document context.
// The Enveloped Signature does not discard comments as per spec; those will be omitted during the transform chain process
if (document == null)
{
throw new CryptographicException(SR.Format(SR.Cryptography_Xml_SelfReferenceRequiresContext, _uri));
}
// Normalize the containing document
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
XmlDocument docWithNoComments = Utils.DiscardComments(Utils.PreProcessDocumentInput(document, resolver, baseUri));
hashInputStream = TransformChain.TransformToOctetStream(docWithNoComments, resolver, baseUri);
}
else if (_uri[0] == '#')
{
// If we get here, then we are constructing a Reference to an embedded DataObject
// referenced by an Id = attribute. Go find the relevant object
bool discardComments = true;
string idref = Utils.GetIdFromLocalUri(_uri, out discardComments);
if (idref == "xpointer(/)")
{
// This is a self referencial case
if (document == null)
{
throw new CryptographicException(SR.Format(SR.Cryptography_Xml_SelfReferenceRequiresContext, _uri));
}
// We should not discard comments here!!!
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
hashInputStream = TransformChain.TransformToOctetStream(Utils.PreProcessDocumentInput(document, resolver, baseUri), resolver, baseUri);
break;
}
XmlElement elem = SignedXml.GetIdElement(document, idref);
if (elem != null)
{
_namespaces = Utils.GetPropagatedAttributes(elem.ParentNode as XmlElement);
}
if (elem == null)
{
// Go throw the referenced items passed in
if (refList != null)
{
foreach (XmlNode node in refList)
{
XmlElement tempElem = node as XmlElement;
if ((tempElem != null) && (Utils.HasAttribute(tempElem, "Id", SignedXml.XmlDsigNamespaceUrl)) &&
(Utils.GetAttribute(tempElem, "Id", SignedXml.XmlDsigNamespaceUrl).Equals(idref)))
{
elem = tempElem;
if (_signedXml._context != null)
{
_namespaces = Utils.GetPropagatedAttributes(_signedXml._context);
}
break;
}
}
}
}
if (elem == null)
{
throw new CryptographicException(SR.Cryptography_Xml_InvalidReference);
}
XmlDocument normDocument = Utils.PreProcessElementInput(elem, resolver, baseUri);
// Add the propagated attributes
Utils.AddNamespaces(normDocument.DocumentElement, _namespaces);
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
if (discardComments)
{
// We should discard comments before going into the transform chain
XmlDocument docWithNoComments = Utils.DiscardComments(normDocument);
hashInputStream = TransformChain.TransformToOctetStream(docWithNoComments, resolver, baseUri);
}
else
{
// This is an XPointer reference, do not discard comments!!!
hashInputStream = TransformChain.TransformToOctetStream(normDocument, resolver, baseUri);
}
}
else
{
throw new CryptographicException(SR.Cryptography_Xml_UriNotResolved, _uri);
}
break;
case ReferenceTargetType.XmlElement:
// We need to create a DocumentNavigator out of the XmlElement
resolver = (SignedXml.ResolverSet ? SignedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
hashInputStream = TransformChain.TransformToOctetStream(Utils.PreProcessElementInput((XmlElement)_refTarget, resolver, baseUri), resolver, baseUri);
break;
default:
throw new CryptographicException(SR.Cryptography_Xml_UriNotResolved, _uri);
}
// Compute the new hash value
hashInputStream = SignedXmlDebugLog.LogReferenceData(this, hashInputStream);
hashval = _hashAlgorithm.ComputeHash(hashInputStream);
}
finally
{
if (hashInputStream != null)
{
hashInputStream.Close();
}
if (response != null)
{
response.Close();
}
if (inputStream != null)
{
inputStream.Close();
}
}
return(hashval);
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver)
{
#if !uap
CheckArguments(input, results);
CheckCommand();
_command.Execute((object)input.CreateNavigator(), documentResolver, arguments, results);
#else
throw new PlatformNotSupportedException(SR.Xslt_NotSupported);
#endif
}
public virtual XmlReader CreateAttributeValidator(
XmlReader reader,
XmlResolver resolver)
{
throw new NotSupportedException();
}
//------------------------------------------------
// Test suites entry points
//------------------------------------------------
private QilExpression TestCompile(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
Reset();
CompileXsltToQil(stylesheet, settings, stylesheetResolver);
return(_qil);
}
private XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile, XmlResolver resolver) {
int errorCount = 0;
if (schema != null) {
if (schema.ErrorCount == 0 && compile) {
if (!schema.CompileSchema(this, resolver, schemaInfo, ns, validationEventHandler, nameTable, true)) {
errorCount = 1;
}
ns = schema.TargetNamespace == null ? string.Empty : schema.TargetNamespace;
}
errorCount += schema.ErrorCount;
}
else {
errorCount += schemaInfo.ErrorCount;
//ns = ns == null? string.Empty : NameTable.Add(ns);
ns = NameTable.Add(ns); //Added without checking for ns == null, since XDR cannot have null namespace
}
if (errorCount == 0) {
XmlSchemaCollectionNode node = new XmlSchemaCollectionNode();
node.NamespaceURI = ns;
node.SchemaInfo = schemaInfo;
node.Schema = schema;
Add(ns, node);
return schema;
}
return null;
}
private void Transform(string inputUri, XsltArgumentList?arguments, XmlWriter results, XmlResolver documentResolver)
{
_command !.Execute(inputUri, documentResolver, arguments, results);
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Load(XmlReader stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
Reset();
LoadInternal(stylesheet, settings, stylesheetResolver);
}
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Load4"]/*' />
public void Load(string url, XmlResolver resolver)
{
Load(new XPathDocument(url, XmlSpace.Preserve), resolver);
}
/// <summary>
/// Executes the query by accessing datasources via the XmlResolver and using
/// run-time parameters as provided by the XsltArgumentList. The default document
/// is mapped into the XmlResolver with the provided name. The results are returned
/// as an IList.
/// </summary>
public override IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList) {
XmlCachedSequenceWriter seqwrt = new XmlCachedSequenceWriter();
Execute(contextDocument, dataSources, argumentList, seqwrt);
return seqwrt.ResultSequence;
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Load(IXPathNavigable stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
Reset();
LoadInternal(stylesheet, settings, stylesheetResolver);
}
/// <summary>
/// Execute the dynamic assembly generated by the XmlILGenerator.
/// </summary>
private void Execute(object defaultDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlSequenceWriter results)
{
Debug.Assert(results != null);
// Ensure that dataSources is always non-null
if (dataSources == null)
dataSources = XmlNullResolver.Singleton;
_delExec(new XmlQueryRuntime(_staticData, defaultDocument, dataSources, argumentList, results));
}
private CompilerErrorCollection LoadInternal(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException(nameof(stylesheet));
}
if (settings == null)
{
settings = XsltSettings.Default;
}
CompileXsltToQil(stylesheet, settings, stylesheetResolver);
CompilerError error = GetFirstError();
if (error != null)
{
throw new XslLoadException(error);
}
if (!settings.CheckOnly)
{
CompileQilToMsil(settings);
}
return(_compilerErrorColl);
}
/// <summary>
/// Default document as XPathNavigator.
/// </summary>
public override void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
Execute(contextDocument, dataSources, argumentList, XmlWriter.Create(results, this.staticData.DefaultWriterSettings));
}
private void CompileXsltToQil(object stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
_compilerErrorColl = new Compiler(settings, _enableDebug, null).Compile(stylesheet, stylesheetResolver, out _qil);
}
internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler) {
if (schemaSet != null) {
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ValidationType = ValidationType.Schema;
readerSettings.Schemas = schemaSet;
readerSettings.ValidationEventHandler += valEventHandler;
return new XsdValidatingReader(reader, resolver, readerSettings, this);
}
return null;
}
internal ExcCanonicalXml(XmlNodeList nodeList, bool includeComments, string inclusiveNamespacesPrefixList, XmlResolver resolver)
{
if (nodeList == null)
{
throw new ArgumentNullException(nameof(nodeList));
}
XmlDocument doc = Utils.GetOwnerDocument(nodeList);
if (doc == null)
{
throw new ArgumentException(nameof(nodeList));
}
_c14nDoc = new CanonicalXmlDocument(false, includeComments);
_c14nDoc.XmlResolver = resolver;
_c14nDoc.Load(new XmlNodeReader(doc));
_ancMgr = new ExcAncestralNamespaceContextManager(inclusiveNamespacesPrefixList);
MarkInclusionStateForNodes(nodeList, doc, _c14nDoc);
}
/// <devdoc> /// <para> /// Executes the query by accessing datasources via the XmlResolver and using /// run-time parameters as provided by the XsltArgumentList. The default document /// is mapped into the XmlResolver with the provided name. The results are returned /// as an IList. /// </para> /// </devdoc> public abstract IList Evaluate(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList);
/// <devdoc> /// <para> /// Executes the query over the provided XPathNavigator with the given XsltArgumentList /// as run-time parameters. The results are output to the provided Stream. /// </para> /// </devdoc> public abstract void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results);
public static CompilerErrorCollection CompileToType(XmlReader stylesheet, XsltSettings settings, XmlResolver stylesheetResolver, TypeBuilder typeBuilder) {
if (stylesheet == null)
throw new ArgumentNullException(nameof(stylesheet));
if (typeBuilder == null)
throw new ArgumentNullException(nameof(typeBuilder));
if (settings == null)
settings = XsltSettings.Default;
CompilerErrorCollection errors;
QilExpression qil;
// Get DebuggableAttribute of the assembly. If there are many of them, JIT seems to pick up a random one.
// I could not discover any pattern here, so let's take the first attribute found.
object[] debuggableAttrs = typeBuilder.Assembly.GetCustomAttributes(typeof(DebuggableAttribute), false);
bool debug = debuggableAttrs.Length > 0 && ((DebuggableAttribute) debuggableAttrs[0]).IsJITTrackingEnabled;
errors = new Compiler(settings, debug).Compile(stylesheet, stylesheetResolver, out qil).Errors;
if (!errors.HasErrors) {
new XmlILGenerator().Generate(qil, typeBuilder);
}
return errors;
}
/// <devdoc> /// <para> /// Executes the query by accessing datasources via the XmlResolver and using /// run-time parameters as provided by the XsltArgumentList. The default document /// is mapped into the XmlResolver with the provided name. The results are output /// to the provided Stream. /// </para> /// </devdoc> public abstract void Execute(XmlReader contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results);
internal XdrBuilder(
XmlReader reader,
XmlNamespaceManager curmgr,
SchemaInfo sinfo,
string targetNamspace,
XmlNameTable nameTable,
SchemaNames schemaNames,
ValidationEventHandler eventhandler
)
{
_SchemaInfo = sinfo;
_TargetNamespace = targetNamspace;
_reader = reader;
_CurNsMgr = curmgr;
_validationEventHandler = eventhandler;
_StateHistory = new HWStack(StackIncrement);
_ElementDef = new ElementContent();
_AttributeDef = new AttributeContent();
_GroupStack = new HWStack(StackIncrement);
_GroupDef = new GroupContent();
_NameTable = nameTable;
_SchemaNames = schemaNames;
_CurState = s_schemaEntries[0];
_positionInfo = PositionInfo.GetPositionInfo(_reader);
_xmlResolver = null;
}
